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"
51 TASK_NOTHING, /* have to be the last element */
56 enum task_position tp;
58 struct task_info *info;
61 static u64 bytes_used = 0;
62 static u64 total_csum_bytes = 0;
63 static u64 total_btree_bytes = 0;
64 static u64 total_fs_tree_bytes = 0;
65 static u64 total_extent_tree_bytes = 0;
66 static u64 btree_space_waste = 0;
67 static u64 data_bytes_allocated = 0;
68 static u64 data_bytes_referenced = 0;
69 static int found_old_backref = 0;
70 static LIST_HEAD(duplicate_extents);
71 static LIST_HEAD(delete_items);
72 static int no_holes = 0;
73 static int init_extent_tree = 0;
74 static int check_data_csum = 0;
75 static struct btrfs_fs_info *global_info;
76 static struct task_ctx ctx = { 0 };
77 static struct cache_tree *roots_info_cache = NULL;
79 enum btrfs_check_mode {
83 CHECK_MODE_DEFAULT = CHECK_MODE_ORIGINAL
86 static enum btrfs_check_mode check_mode = CHECK_MODE_DEFAULT;
88 struct extent_backref {
89 struct list_head list;
90 unsigned int is_data:1;
91 unsigned int found_extent_tree:1;
92 unsigned int full_backref:1;
93 unsigned int found_ref:1;
94 unsigned int broken:1;
97 static inline struct extent_backref* to_extent_backref(struct list_head *entry)
99 return list_entry(entry, struct extent_backref, list);
102 struct data_backref {
103 struct extent_backref node;
117 #define ROOT_DIR_ERROR (1<<1) /* bad ROOT_DIR */
118 #define DIR_ITEM_MISSING (1<<2) /* DIR_ITEM not found */
119 #define DIR_ITEM_MISMATCH (1<<3) /* DIR_ITEM found but not match */
120 #define INODE_REF_MISSING (1<<4) /* INODE_REF/INODE_EXTREF not found */
121 #define INODE_ITEM_MISSING (1<<5) /* INODE_ITEM not found */
122 #define INODE_ITEM_MISMATCH (1<<6) /* INODE_ITEM found but not match */
123 #define FILE_EXTENT_ERROR (1<<7) /* bad FILE_EXTENT */
124 #define ODD_CSUM_ITEM (1<<8) /* CSUM_ITEM error */
125 #define CSUM_ITEM_MISSING (1<<9) /* CSUM_ITEM not found */
126 #define LINK_COUNT_ERROR (1<<10) /* INODE_ITEM nlink count error */
127 #define NBYTES_ERROR (1<<11) /* INODE_ITEM nbytes count error */
128 #define ISIZE_ERROR (1<<12) /* INODE_ITEM size count error */
129 #define ORPHAN_ITEM (1<<13) /* INODE_ITEM no reference */
130 #define NO_INODE_ITEM (1<<14) /* no inode_item */
131 #define LAST_ITEM (1<<15) /* Complete this tree traversal */
132 #define ROOT_REF_MISSING (1<<16) /* ROOT_REF not found */
133 #define ROOT_REF_MISMATCH (1<<17) /* ROOT_REF found but not match */
135 static inline struct data_backref* to_data_backref(struct extent_backref *back)
137 return container_of(back, struct data_backref, node);
141 * Much like data_backref, just removed the undetermined members
142 * and change it to use list_head.
143 * During extent scan, it is stored in root->orphan_data_extent.
144 * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
146 struct orphan_data_extent {
147 struct list_head list;
155 struct tree_backref {
156 struct extent_backref node;
163 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
165 return container_of(back, struct tree_backref, node);
168 /* Explicit initialization for extent_record::flag_block_full_backref */
169 enum { FLAG_UNSET = 2 };
171 struct extent_record {
172 struct list_head backrefs;
173 struct list_head dups;
174 struct list_head list;
175 struct cache_extent cache;
176 struct btrfs_disk_key parent_key;
181 u64 extent_item_refs;
183 u64 parent_generation;
187 unsigned int flag_block_full_backref:2;
188 unsigned int found_rec:1;
189 unsigned int content_checked:1;
190 unsigned int owner_ref_checked:1;
191 unsigned int is_root:1;
192 unsigned int metadata:1;
193 unsigned int bad_full_backref:1;
194 unsigned int crossing_stripes:1;
195 unsigned int wrong_chunk_type:1;
198 static inline struct extent_record* to_extent_record(struct list_head *entry)
200 return container_of(entry, struct extent_record, list);
203 struct inode_backref {
204 struct list_head list;
205 unsigned int found_dir_item:1;
206 unsigned int found_dir_index:1;
207 unsigned int found_inode_ref:1;
217 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
219 return list_entry(entry, struct inode_backref, list);
222 struct root_item_record {
223 struct list_head list;
230 struct btrfs_key drop_key;
233 #define REF_ERR_NO_DIR_ITEM (1 << 0)
234 #define REF_ERR_NO_DIR_INDEX (1 << 1)
235 #define REF_ERR_NO_INODE_REF (1 << 2)
236 #define REF_ERR_DUP_DIR_ITEM (1 << 3)
237 #define REF_ERR_DUP_DIR_INDEX (1 << 4)
238 #define REF_ERR_DUP_INODE_REF (1 << 5)
239 #define REF_ERR_INDEX_UNMATCH (1 << 6)
240 #define REF_ERR_FILETYPE_UNMATCH (1 << 7)
241 #define REF_ERR_NAME_TOO_LONG (1 << 8) // 100
242 #define REF_ERR_NO_ROOT_REF (1 << 9)
243 #define REF_ERR_NO_ROOT_BACKREF (1 << 10)
244 #define REF_ERR_DUP_ROOT_REF (1 << 11)
245 #define REF_ERR_DUP_ROOT_BACKREF (1 << 12)
247 struct file_extent_hole {
253 struct inode_record {
254 struct list_head backrefs;
255 unsigned int checked:1;
256 unsigned int merging:1;
257 unsigned int found_inode_item:1;
258 unsigned int found_dir_item:1;
259 unsigned int found_file_extent:1;
260 unsigned int found_csum_item:1;
261 unsigned int some_csum_missing:1;
262 unsigned int nodatasum:1;
275 struct rb_root holes;
276 struct list_head orphan_extents;
281 #define I_ERR_NO_INODE_ITEM (1 << 0)
282 #define I_ERR_NO_ORPHAN_ITEM (1 << 1)
283 #define I_ERR_DUP_INODE_ITEM (1 << 2)
284 #define I_ERR_DUP_DIR_INDEX (1 << 3)
285 #define I_ERR_ODD_DIR_ITEM (1 << 4)
286 #define I_ERR_ODD_FILE_EXTENT (1 << 5)
287 #define I_ERR_BAD_FILE_EXTENT (1 << 6)
288 #define I_ERR_FILE_EXTENT_OVERLAP (1 << 7)
289 #define I_ERR_FILE_EXTENT_DISCOUNT (1 << 8) // 100
290 #define I_ERR_DIR_ISIZE_WRONG (1 << 9)
291 #define I_ERR_FILE_NBYTES_WRONG (1 << 10) // 400
292 #define I_ERR_ODD_CSUM_ITEM (1 << 11)
293 #define I_ERR_SOME_CSUM_MISSING (1 << 12)
294 #define I_ERR_LINK_COUNT_WRONG (1 << 13)
295 #define I_ERR_FILE_EXTENT_ORPHAN (1 << 14)
297 struct root_backref {
298 struct list_head list;
299 unsigned int found_dir_item:1;
300 unsigned int found_dir_index:1;
301 unsigned int found_back_ref:1;
302 unsigned int found_forward_ref:1;
303 unsigned int reachable:1;
312 static inline struct root_backref* to_root_backref(struct list_head *entry)
314 return list_entry(entry, struct root_backref, list);
318 struct list_head backrefs;
319 struct cache_extent cache;
320 unsigned int found_root_item:1;
326 struct cache_extent cache;
331 struct cache_extent cache;
332 struct cache_tree root_cache;
333 struct cache_tree inode_cache;
334 struct inode_record *current;
343 struct walk_control {
344 struct cache_tree shared;
345 struct shared_node *nodes[BTRFS_MAX_LEVEL];
351 struct btrfs_key key;
353 struct list_head list;
356 struct extent_entry {
361 struct list_head list;
364 struct root_item_info {
365 /* level of the root */
367 /* number of nodes at this level, must be 1 for a root */
371 struct cache_extent cache_extent;
375 * Error bit for low memory mode check.
377 * Currently no caller cares about it yet. Just internal use for error
380 #define BACKREF_MISSING (1 << 0) /* Backref missing in extent tree */
381 #define BACKREF_MISMATCH (1 << 1) /* Backref exists but does not match */
382 #define BYTES_UNALIGNED (1 << 2) /* Some bytes are not aligned */
383 #define REFERENCER_MISSING (1 << 3) /* Referencer not found */
384 #define REFERENCER_MISMATCH (1 << 4) /* Referenceer found but does not match */
385 #define CROSSING_STRIPE_BOUNDARY (1 << 4) /* For kernel scrub workaround */
386 #define ITEM_SIZE_MISMATCH (1 << 5) /* Bad item size */
387 #define UNKNOWN_TYPE (1 << 6) /* Unknown type */
388 #define ACCOUNTING_MISMATCH (1 << 7) /* Used space accounting error */
389 #define CHUNK_TYPE_MISMATCH (1 << 8)
391 static void *print_status_check(void *p)
393 struct task_ctx *priv = p;
394 const char work_indicator[] = { '.', 'o', 'O', 'o' };
396 static char *task_position_string[] = {
398 "checking free space cache",
402 task_period_start(priv->info, 1000 /* 1s */);
404 if (priv->tp == TASK_NOTHING)
408 printf("%s [%c]\r", task_position_string[priv->tp],
409 work_indicator[count % 4]);
412 task_period_wait(priv->info);
417 static int print_status_return(void *p)
425 static enum btrfs_check_mode parse_check_mode(const char *str)
427 if (strcmp(str, "lowmem") == 0)
428 return CHECK_MODE_LOWMEM;
429 if (strcmp(str, "orig") == 0)
430 return CHECK_MODE_ORIGINAL;
431 if (strcmp(str, "original") == 0)
432 return CHECK_MODE_ORIGINAL;
434 return CHECK_MODE_UNKNOWN;
437 /* Compatible function to allow reuse of old codes */
438 static u64 first_extent_gap(struct rb_root *holes)
440 struct file_extent_hole *hole;
442 if (RB_EMPTY_ROOT(holes))
445 hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
449 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
451 struct file_extent_hole *hole1;
452 struct file_extent_hole *hole2;
454 hole1 = rb_entry(node1, struct file_extent_hole, node);
455 hole2 = rb_entry(node2, struct file_extent_hole, node);
457 if (hole1->start > hole2->start)
459 if (hole1->start < hole2->start)
461 /* Now hole1->start == hole2->start */
462 if (hole1->len >= hole2->len)
464 * Hole 1 will be merge center
465 * Same hole will be merged later
468 /* Hole 2 will be merge center */
473 * Add a hole to the record
475 * This will do hole merge for copy_file_extent_holes(),
476 * which will ensure there won't be continuous holes.
478 static int add_file_extent_hole(struct rb_root *holes,
481 struct file_extent_hole *hole;
482 struct file_extent_hole *prev = NULL;
483 struct file_extent_hole *next = NULL;
485 hole = malloc(sizeof(*hole));
490 /* Since compare will not return 0, no -EEXIST will happen */
491 rb_insert(holes, &hole->node, compare_hole);
493 /* simple merge with previous hole */
494 if (rb_prev(&hole->node))
495 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
497 if (prev && prev->start + prev->len >= hole->start) {
498 hole->len = hole->start + hole->len - prev->start;
499 hole->start = prev->start;
500 rb_erase(&prev->node, holes);
505 /* iterate merge with next holes */
507 if (!rb_next(&hole->node))
509 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
511 if (hole->start + hole->len >= next->start) {
512 if (hole->start + hole->len <= next->start + next->len)
513 hole->len = next->start + next->len -
515 rb_erase(&next->node, holes);
524 static int compare_hole_range(struct rb_node *node, void *data)
526 struct file_extent_hole *hole;
529 hole = (struct file_extent_hole *)data;
532 hole = rb_entry(node, struct file_extent_hole, node);
533 if (start < hole->start)
535 if (start >= hole->start && start < hole->start + hole->len)
541 * Delete a hole in the record
543 * This will do the hole split and is much restrict than add.
545 static int del_file_extent_hole(struct rb_root *holes,
548 struct file_extent_hole *hole;
549 struct file_extent_hole tmp;
554 struct rb_node *node;
561 node = rb_search(holes, &tmp, compare_hole_range, NULL);
564 hole = rb_entry(node, struct file_extent_hole, node);
565 if (start + len > hole->start + hole->len)
569 * Now there will be no overlap, delete the hole and re-add the
570 * split(s) if they exists.
572 if (start > hole->start) {
573 prev_start = hole->start;
574 prev_len = start - hole->start;
577 if (hole->start + hole->len > start + len) {
578 next_start = start + len;
579 next_len = hole->start + hole->len - start - len;
582 rb_erase(node, holes);
585 ret = add_file_extent_hole(holes, prev_start, prev_len);
590 ret = add_file_extent_hole(holes, next_start, next_len);
597 static int copy_file_extent_holes(struct rb_root *dst,
600 struct file_extent_hole *hole;
601 struct rb_node *node;
604 node = rb_first(src);
606 hole = rb_entry(node, struct file_extent_hole, node);
607 ret = add_file_extent_hole(dst, hole->start, hole->len);
610 node = rb_next(node);
615 static void free_file_extent_holes(struct rb_root *holes)
617 struct rb_node *node;
618 struct file_extent_hole *hole;
620 node = rb_first(holes);
622 hole = rb_entry(node, struct file_extent_hole, node);
623 rb_erase(node, holes);
625 node = rb_first(holes);
629 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
631 static void record_root_in_trans(struct btrfs_trans_handle *trans,
632 struct btrfs_root *root)
634 if (root->last_trans != trans->transid) {
635 root->track_dirty = 1;
636 root->last_trans = trans->transid;
637 root->commit_root = root->node;
638 extent_buffer_get(root->node);
642 static u8 imode_to_type(u32 imode)
645 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
646 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
647 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
648 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
649 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
650 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
651 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
652 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
655 return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
659 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
661 struct device_record *rec1;
662 struct device_record *rec2;
664 rec1 = rb_entry(node1, struct device_record, node);
665 rec2 = rb_entry(node2, struct device_record, node);
666 if (rec1->devid > rec2->devid)
668 else if (rec1->devid < rec2->devid)
674 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
676 struct inode_record *rec;
677 struct inode_backref *backref;
678 struct inode_backref *orig;
679 struct inode_backref *tmp;
680 struct orphan_data_extent *src_orphan;
681 struct orphan_data_extent *dst_orphan;
686 rec = malloc(sizeof(*rec));
688 return ERR_PTR(-ENOMEM);
689 memcpy(rec, orig_rec, sizeof(*rec));
691 INIT_LIST_HEAD(&rec->backrefs);
692 INIT_LIST_HEAD(&rec->orphan_extents);
693 rec->holes = RB_ROOT;
695 list_for_each_entry(orig, &orig_rec->backrefs, list) {
696 size = sizeof(*orig) + orig->namelen + 1;
697 backref = malloc(size);
702 memcpy(backref, orig, size);
703 list_add_tail(&backref->list, &rec->backrefs);
705 list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
706 dst_orphan = malloc(sizeof(*dst_orphan));
711 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
712 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
714 ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
721 rb = rb_first(&rec->holes);
723 struct file_extent_hole *hole;
725 hole = rb_entry(rb, struct file_extent_hole, node);
731 if (!list_empty(&rec->backrefs))
732 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
733 list_del(&orig->list);
737 if (!list_empty(&rec->orphan_extents))
738 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
739 list_del(&orig->list);
748 static void print_orphan_data_extents(struct list_head *orphan_extents,
751 struct orphan_data_extent *orphan;
753 if (list_empty(orphan_extents))
755 printf("The following data extent is lost in tree %llu:\n",
757 list_for_each_entry(orphan, orphan_extents, list) {
758 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
759 orphan->objectid, orphan->offset, orphan->disk_bytenr,
764 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
766 u64 root_objectid = root->root_key.objectid;
767 int errors = rec->errors;
771 /* reloc root errors, we print its corresponding fs root objectid*/
772 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
773 root_objectid = root->root_key.offset;
774 fprintf(stderr, "reloc");
776 fprintf(stderr, "root %llu inode %llu errors %x",
777 (unsigned long long) root_objectid,
778 (unsigned long long) rec->ino, rec->errors);
780 if (errors & I_ERR_NO_INODE_ITEM)
781 fprintf(stderr, ", no inode item");
782 if (errors & I_ERR_NO_ORPHAN_ITEM)
783 fprintf(stderr, ", no orphan item");
784 if (errors & I_ERR_DUP_INODE_ITEM)
785 fprintf(stderr, ", dup inode item");
786 if (errors & I_ERR_DUP_DIR_INDEX)
787 fprintf(stderr, ", dup dir index");
788 if (errors & I_ERR_ODD_DIR_ITEM)
789 fprintf(stderr, ", odd dir item");
790 if (errors & I_ERR_ODD_FILE_EXTENT)
791 fprintf(stderr, ", odd file extent");
792 if (errors & I_ERR_BAD_FILE_EXTENT)
793 fprintf(stderr, ", bad file extent");
794 if (errors & I_ERR_FILE_EXTENT_OVERLAP)
795 fprintf(stderr, ", file extent overlap");
796 if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
797 fprintf(stderr, ", file extent discount");
798 if (errors & I_ERR_DIR_ISIZE_WRONG)
799 fprintf(stderr, ", dir isize wrong");
800 if (errors & I_ERR_FILE_NBYTES_WRONG)
801 fprintf(stderr, ", nbytes wrong");
802 if (errors & I_ERR_ODD_CSUM_ITEM)
803 fprintf(stderr, ", odd csum item");
804 if (errors & I_ERR_SOME_CSUM_MISSING)
805 fprintf(stderr, ", some csum missing");
806 if (errors & I_ERR_LINK_COUNT_WRONG)
807 fprintf(stderr, ", link count wrong");
808 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
809 fprintf(stderr, ", orphan file extent");
810 fprintf(stderr, "\n");
811 /* Print the orphan extents if needed */
812 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
813 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
815 /* Print the holes if needed */
816 if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
817 struct file_extent_hole *hole;
818 struct rb_node *node;
821 node = rb_first(&rec->holes);
822 fprintf(stderr, "Found file extent holes:\n");
825 hole = rb_entry(node, struct file_extent_hole, node);
826 fprintf(stderr, "\tstart: %llu, len: %llu\n",
827 hole->start, hole->len);
828 node = rb_next(node);
831 fprintf(stderr, "\tstart: 0, len: %llu\n",
832 round_up(rec->isize, root->sectorsize));
836 static void print_ref_error(int errors)
838 if (errors & REF_ERR_NO_DIR_ITEM)
839 fprintf(stderr, ", no dir item");
840 if (errors & REF_ERR_NO_DIR_INDEX)
841 fprintf(stderr, ", no dir index");
842 if (errors & REF_ERR_NO_INODE_REF)
843 fprintf(stderr, ", no inode ref");
844 if (errors & REF_ERR_DUP_DIR_ITEM)
845 fprintf(stderr, ", dup dir item");
846 if (errors & REF_ERR_DUP_DIR_INDEX)
847 fprintf(stderr, ", dup dir index");
848 if (errors & REF_ERR_DUP_INODE_REF)
849 fprintf(stderr, ", dup inode ref");
850 if (errors & REF_ERR_INDEX_UNMATCH)
851 fprintf(stderr, ", index mismatch");
852 if (errors & REF_ERR_FILETYPE_UNMATCH)
853 fprintf(stderr, ", filetype mismatch");
854 if (errors & REF_ERR_NAME_TOO_LONG)
855 fprintf(stderr, ", name too long");
856 if (errors & REF_ERR_NO_ROOT_REF)
857 fprintf(stderr, ", no root ref");
858 if (errors & REF_ERR_NO_ROOT_BACKREF)
859 fprintf(stderr, ", no root backref");
860 if (errors & REF_ERR_DUP_ROOT_REF)
861 fprintf(stderr, ", dup root ref");
862 if (errors & REF_ERR_DUP_ROOT_BACKREF)
863 fprintf(stderr, ", dup root backref");
864 fprintf(stderr, "\n");
867 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
870 struct ptr_node *node;
871 struct cache_extent *cache;
872 struct inode_record *rec = NULL;
875 cache = lookup_cache_extent(inode_cache, ino, 1);
877 node = container_of(cache, struct ptr_node, cache);
879 if (mod && rec->refs > 1) {
880 node->data = clone_inode_rec(rec);
881 if (IS_ERR(node->data))
887 rec = calloc(1, sizeof(*rec));
889 return ERR_PTR(-ENOMEM);
891 rec->extent_start = (u64)-1;
893 INIT_LIST_HEAD(&rec->backrefs);
894 INIT_LIST_HEAD(&rec->orphan_extents);
895 rec->holes = RB_ROOT;
897 node = malloc(sizeof(*node));
900 return ERR_PTR(-ENOMEM);
902 node->cache.start = ino;
903 node->cache.size = 1;
906 if (ino == BTRFS_FREE_INO_OBJECTID)
909 ret = insert_cache_extent(inode_cache, &node->cache);
911 return ERR_PTR(-EEXIST);
916 static void free_orphan_data_extents(struct list_head *orphan_extents)
918 struct orphan_data_extent *orphan;
920 while (!list_empty(orphan_extents)) {
921 orphan = list_entry(orphan_extents->next,
922 struct orphan_data_extent, list);
923 list_del(&orphan->list);
928 static void free_inode_rec(struct inode_record *rec)
930 struct inode_backref *backref;
935 while (!list_empty(&rec->backrefs)) {
936 backref = to_inode_backref(rec->backrefs.next);
937 list_del(&backref->list);
940 free_orphan_data_extents(&rec->orphan_extents);
941 free_file_extent_holes(&rec->holes);
945 static int can_free_inode_rec(struct inode_record *rec)
947 if (!rec->errors && rec->checked && rec->found_inode_item &&
948 rec->nlink == rec->found_link && list_empty(&rec->backrefs))
953 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
954 struct inode_record *rec)
956 struct cache_extent *cache;
957 struct inode_backref *tmp, *backref;
958 struct ptr_node *node;
961 if (!rec->found_inode_item)
964 filetype = imode_to_type(rec->imode);
965 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
966 if (backref->found_dir_item && backref->found_dir_index) {
967 if (backref->filetype != filetype)
968 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
969 if (!backref->errors && backref->found_inode_ref &&
970 rec->nlink == rec->found_link) {
971 list_del(&backref->list);
977 if (!rec->checked || rec->merging)
980 if (S_ISDIR(rec->imode)) {
981 if (rec->found_size != rec->isize)
982 rec->errors |= I_ERR_DIR_ISIZE_WRONG;
983 if (rec->found_file_extent)
984 rec->errors |= I_ERR_ODD_FILE_EXTENT;
985 } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
986 if (rec->found_dir_item)
987 rec->errors |= I_ERR_ODD_DIR_ITEM;
988 if (rec->found_size != rec->nbytes)
989 rec->errors |= I_ERR_FILE_NBYTES_WRONG;
990 if (rec->nlink > 0 && !no_holes &&
991 (rec->extent_end < rec->isize ||
992 first_extent_gap(&rec->holes) < rec->isize))
993 rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
996 if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
997 if (rec->found_csum_item && rec->nodatasum)
998 rec->errors |= I_ERR_ODD_CSUM_ITEM;
999 if (rec->some_csum_missing && !rec->nodatasum)
1000 rec->errors |= I_ERR_SOME_CSUM_MISSING;
1003 BUG_ON(rec->refs != 1);
1004 if (can_free_inode_rec(rec)) {
1005 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
1006 node = container_of(cache, struct ptr_node, cache);
1007 BUG_ON(node->data != rec);
1008 remove_cache_extent(inode_cache, &node->cache);
1010 free_inode_rec(rec);
1014 static int check_orphan_item(struct btrfs_root *root, u64 ino)
1016 struct btrfs_path path;
1017 struct btrfs_key key;
1020 key.objectid = BTRFS_ORPHAN_OBJECTID;
1021 key.type = BTRFS_ORPHAN_ITEM_KEY;
1024 btrfs_init_path(&path);
1025 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1026 btrfs_release_path(&path);
1032 static int process_inode_item(struct extent_buffer *eb,
1033 int slot, struct btrfs_key *key,
1034 struct shared_node *active_node)
1036 struct inode_record *rec;
1037 struct btrfs_inode_item *item;
1039 rec = active_node->current;
1040 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1041 if (rec->found_inode_item) {
1042 rec->errors |= I_ERR_DUP_INODE_ITEM;
1045 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
1046 rec->nlink = btrfs_inode_nlink(eb, item);
1047 rec->isize = btrfs_inode_size(eb, item);
1048 rec->nbytes = btrfs_inode_nbytes(eb, item);
1049 rec->imode = btrfs_inode_mode(eb, item);
1050 if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
1052 rec->found_inode_item = 1;
1053 if (rec->nlink == 0)
1054 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
1055 maybe_free_inode_rec(&active_node->inode_cache, rec);
1059 static struct inode_backref *get_inode_backref(struct inode_record *rec,
1061 int namelen, u64 dir)
1063 struct inode_backref *backref;
1065 list_for_each_entry(backref, &rec->backrefs, list) {
1066 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
1068 if (backref->dir != dir || backref->namelen != namelen)
1070 if (memcmp(name, backref->name, namelen))
1075 backref = malloc(sizeof(*backref) + namelen + 1);
1078 memset(backref, 0, sizeof(*backref));
1080 backref->namelen = namelen;
1081 memcpy(backref->name, name, namelen);
1082 backref->name[namelen] = '\0';
1083 list_add_tail(&backref->list, &rec->backrefs);
1087 static int add_inode_backref(struct cache_tree *inode_cache,
1088 u64 ino, u64 dir, u64 index,
1089 const char *name, int namelen,
1090 u8 filetype, u8 itemtype, int errors)
1092 struct inode_record *rec;
1093 struct inode_backref *backref;
1095 rec = get_inode_rec(inode_cache, ino, 1);
1096 BUG_ON(IS_ERR(rec));
1097 backref = get_inode_backref(rec, name, namelen, dir);
1100 backref->errors |= errors;
1101 if (itemtype == BTRFS_DIR_INDEX_KEY) {
1102 if (backref->found_dir_index)
1103 backref->errors |= REF_ERR_DUP_DIR_INDEX;
1104 if (backref->found_inode_ref && backref->index != index)
1105 backref->errors |= REF_ERR_INDEX_UNMATCH;
1106 if (backref->found_dir_item && backref->filetype != filetype)
1107 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1109 backref->index = index;
1110 backref->filetype = filetype;
1111 backref->found_dir_index = 1;
1112 } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1114 if (backref->found_dir_item)
1115 backref->errors |= REF_ERR_DUP_DIR_ITEM;
1116 if (backref->found_dir_index && backref->filetype != filetype)
1117 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1119 backref->filetype = filetype;
1120 backref->found_dir_item = 1;
1121 } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1122 (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1123 if (backref->found_inode_ref)
1124 backref->errors |= REF_ERR_DUP_INODE_REF;
1125 if (backref->found_dir_index && backref->index != index)
1126 backref->errors |= REF_ERR_INDEX_UNMATCH;
1128 backref->index = index;
1130 backref->ref_type = itemtype;
1131 backref->found_inode_ref = 1;
1136 maybe_free_inode_rec(inode_cache, rec);
1140 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1141 struct cache_tree *dst_cache)
1143 struct inode_backref *backref;
1148 list_for_each_entry(backref, &src->backrefs, list) {
1149 if (backref->found_dir_index) {
1150 add_inode_backref(dst_cache, dst->ino, backref->dir,
1151 backref->index, backref->name,
1152 backref->namelen, backref->filetype,
1153 BTRFS_DIR_INDEX_KEY, backref->errors);
1155 if (backref->found_dir_item) {
1157 add_inode_backref(dst_cache, dst->ino,
1158 backref->dir, 0, backref->name,
1159 backref->namelen, backref->filetype,
1160 BTRFS_DIR_ITEM_KEY, backref->errors);
1162 if (backref->found_inode_ref) {
1163 add_inode_backref(dst_cache, dst->ino,
1164 backref->dir, backref->index,
1165 backref->name, backref->namelen, 0,
1166 backref->ref_type, backref->errors);
1170 if (src->found_dir_item)
1171 dst->found_dir_item = 1;
1172 if (src->found_file_extent)
1173 dst->found_file_extent = 1;
1174 if (src->found_csum_item)
1175 dst->found_csum_item = 1;
1176 if (src->some_csum_missing)
1177 dst->some_csum_missing = 1;
1178 if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1179 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1184 BUG_ON(src->found_link < dir_count);
1185 dst->found_link += src->found_link - dir_count;
1186 dst->found_size += src->found_size;
1187 if (src->extent_start != (u64)-1) {
1188 if (dst->extent_start == (u64)-1) {
1189 dst->extent_start = src->extent_start;
1190 dst->extent_end = src->extent_end;
1192 if (dst->extent_end > src->extent_start)
1193 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1194 else if (dst->extent_end < src->extent_start) {
1195 ret = add_file_extent_hole(&dst->holes,
1197 src->extent_start - dst->extent_end);
1199 if (dst->extent_end < src->extent_end)
1200 dst->extent_end = src->extent_end;
1204 dst->errors |= src->errors;
1205 if (src->found_inode_item) {
1206 if (!dst->found_inode_item) {
1207 dst->nlink = src->nlink;
1208 dst->isize = src->isize;
1209 dst->nbytes = src->nbytes;
1210 dst->imode = src->imode;
1211 dst->nodatasum = src->nodatasum;
1212 dst->found_inode_item = 1;
1214 dst->errors |= I_ERR_DUP_INODE_ITEM;
1222 static int splice_shared_node(struct shared_node *src_node,
1223 struct shared_node *dst_node)
1225 struct cache_extent *cache;
1226 struct ptr_node *node, *ins;
1227 struct cache_tree *src, *dst;
1228 struct inode_record *rec, *conflict;
1229 u64 current_ino = 0;
1233 if (--src_node->refs == 0)
1235 if (src_node->current)
1236 current_ino = src_node->current->ino;
1238 src = &src_node->root_cache;
1239 dst = &dst_node->root_cache;
1241 cache = search_cache_extent(src, 0);
1243 node = container_of(cache, struct ptr_node, cache);
1245 cache = next_cache_extent(cache);
1248 remove_cache_extent(src, &node->cache);
1251 ins = malloc(sizeof(*ins));
1253 ins->cache.start = node->cache.start;
1254 ins->cache.size = node->cache.size;
1258 ret = insert_cache_extent(dst, &ins->cache);
1259 if (ret == -EEXIST) {
1260 conflict = get_inode_rec(dst, rec->ino, 1);
1261 BUG_ON(IS_ERR(conflict));
1262 merge_inode_recs(rec, conflict, dst);
1264 conflict->checked = 1;
1265 if (dst_node->current == conflict)
1266 dst_node->current = NULL;
1268 maybe_free_inode_rec(dst, conflict);
1269 free_inode_rec(rec);
1276 if (src == &src_node->root_cache) {
1277 src = &src_node->inode_cache;
1278 dst = &dst_node->inode_cache;
1282 if (current_ino > 0 && (!dst_node->current ||
1283 current_ino > dst_node->current->ino)) {
1284 if (dst_node->current) {
1285 dst_node->current->checked = 1;
1286 maybe_free_inode_rec(dst, dst_node->current);
1288 dst_node->current = get_inode_rec(dst, current_ino, 1);
1289 BUG_ON(IS_ERR(dst_node->current));
1294 static void free_inode_ptr(struct cache_extent *cache)
1296 struct ptr_node *node;
1297 struct inode_record *rec;
1299 node = container_of(cache, struct ptr_node, cache);
1301 free_inode_rec(rec);
1305 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1307 static struct shared_node *find_shared_node(struct cache_tree *shared,
1310 struct cache_extent *cache;
1311 struct shared_node *node;
1313 cache = lookup_cache_extent(shared, bytenr, 1);
1315 node = container_of(cache, struct shared_node, cache);
1321 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1324 struct shared_node *node;
1326 node = calloc(1, sizeof(*node));
1329 node->cache.start = bytenr;
1330 node->cache.size = 1;
1331 cache_tree_init(&node->root_cache);
1332 cache_tree_init(&node->inode_cache);
1335 ret = insert_cache_extent(shared, &node->cache);
1340 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1341 struct walk_control *wc, int level)
1343 struct shared_node *node;
1344 struct shared_node *dest;
1347 if (level == wc->active_node)
1350 BUG_ON(wc->active_node <= level);
1351 node = find_shared_node(&wc->shared, bytenr);
1353 ret = add_shared_node(&wc->shared, bytenr, refs);
1355 node = find_shared_node(&wc->shared, bytenr);
1356 wc->nodes[level] = node;
1357 wc->active_node = level;
1361 if (wc->root_level == wc->active_node &&
1362 btrfs_root_refs(&root->root_item) == 0) {
1363 if (--node->refs == 0) {
1364 free_inode_recs_tree(&node->root_cache);
1365 free_inode_recs_tree(&node->inode_cache);
1366 remove_cache_extent(&wc->shared, &node->cache);
1372 dest = wc->nodes[wc->active_node];
1373 splice_shared_node(node, dest);
1374 if (node->refs == 0) {
1375 remove_cache_extent(&wc->shared, &node->cache);
1381 static int leave_shared_node(struct btrfs_root *root,
1382 struct walk_control *wc, int level)
1384 struct shared_node *node;
1385 struct shared_node *dest;
1388 if (level == wc->root_level)
1391 for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1395 BUG_ON(i >= BTRFS_MAX_LEVEL);
1397 node = wc->nodes[wc->active_node];
1398 wc->nodes[wc->active_node] = NULL;
1399 wc->active_node = i;
1401 dest = wc->nodes[wc->active_node];
1402 if (wc->active_node < wc->root_level ||
1403 btrfs_root_refs(&root->root_item) > 0) {
1404 BUG_ON(node->refs <= 1);
1405 splice_shared_node(node, dest);
1407 BUG_ON(node->refs < 2);
1416 * 1 - if the root with id child_root_id is a child of root parent_root_id
1417 * 0 - if the root child_root_id isn't a child of the root parent_root_id but
1418 * has other root(s) as parent(s)
1419 * 2 - if the root child_root_id doesn't have any parent roots
1421 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1424 struct btrfs_path path;
1425 struct btrfs_key key;
1426 struct extent_buffer *leaf;
1430 btrfs_init_path(&path);
1432 key.objectid = parent_root_id;
1433 key.type = BTRFS_ROOT_REF_KEY;
1434 key.offset = child_root_id;
1435 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1439 btrfs_release_path(&path);
1443 key.objectid = child_root_id;
1444 key.type = BTRFS_ROOT_BACKREF_KEY;
1446 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1452 leaf = path.nodes[0];
1453 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1454 ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1457 leaf = path.nodes[0];
1460 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1461 if (key.objectid != child_root_id ||
1462 key.type != BTRFS_ROOT_BACKREF_KEY)
1467 if (key.offset == parent_root_id) {
1468 btrfs_release_path(&path);
1475 btrfs_release_path(&path);
1478 return has_parent ? 0 : 2;
1481 static int process_dir_item(struct btrfs_root *root,
1482 struct extent_buffer *eb,
1483 int slot, struct btrfs_key *key,
1484 struct shared_node *active_node)
1494 struct btrfs_dir_item *di;
1495 struct inode_record *rec;
1496 struct cache_tree *root_cache;
1497 struct cache_tree *inode_cache;
1498 struct btrfs_key location;
1499 char namebuf[BTRFS_NAME_LEN];
1501 root_cache = &active_node->root_cache;
1502 inode_cache = &active_node->inode_cache;
1503 rec = active_node->current;
1504 rec->found_dir_item = 1;
1506 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1507 total = btrfs_item_size_nr(eb, slot);
1508 while (cur < total) {
1510 btrfs_dir_item_key_to_cpu(eb, di, &location);
1511 name_len = btrfs_dir_name_len(eb, di);
1512 data_len = btrfs_dir_data_len(eb, di);
1513 filetype = btrfs_dir_type(eb, di);
1515 rec->found_size += name_len;
1516 if (name_len <= BTRFS_NAME_LEN) {
1520 len = BTRFS_NAME_LEN;
1521 error = REF_ERR_NAME_TOO_LONG;
1523 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1525 if (location.type == BTRFS_INODE_ITEM_KEY) {
1526 add_inode_backref(inode_cache, location.objectid,
1527 key->objectid, key->offset, namebuf,
1528 len, filetype, key->type, error);
1529 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1530 add_inode_backref(root_cache, location.objectid,
1531 key->objectid, key->offset,
1532 namebuf, len, filetype,
1535 fprintf(stderr, "invalid location in dir item %u\n",
1537 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1538 key->objectid, key->offset, namebuf,
1539 len, filetype, key->type, error);
1542 len = sizeof(*di) + name_len + data_len;
1543 di = (struct btrfs_dir_item *)((char *)di + len);
1546 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1547 rec->errors |= I_ERR_DUP_DIR_INDEX;
1552 static int process_inode_ref(struct extent_buffer *eb,
1553 int slot, struct btrfs_key *key,
1554 struct shared_node *active_node)
1562 struct cache_tree *inode_cache;
1563 struct btrfs_inode_ref *ref;
1564 char namebuf[BTRFS_NAME_LEN];
1566 inode_cache = &active_node->inode_cache;
1568 ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1569 total = btrfs_item_size_nr(eb, slot);
1570 while (cur < total) {
1571 name_len = btrfs_inode_ref_name_len(eb, ref);
1572 index = btrfs_inode_ref_index(eb, ref);
1573 if (name_len <= BTRFS_NAME_LEN) {
1577 len = BTRFS_NAME_LEN;
1578 error = REF_ERR_NAME_TOO_LONG;
1580 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1581 add_inode_backref(inode_cache, key->objectid, key->offset,
1582 index, namebuf, len, 0, key->type, error);
1584 len = sizeof(*ref) + name_len;
1585 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1591 static int process_inode_extref(struct extent_buffer *eb,
1592 int slot, struct btrfs_key *key,
1593 struct shared_node *active_node)
1602 struct cache_tree *inode_cache;
1603 struct btrfs_inode_extref *extref;
1604 char namebuf[BTRFS_NAME_LEN];
1606 inode_cache = &active_node->inode_cache;
1608 extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1609 total = btrfs_item_size_nr(eb, slot);
1610 while (cur < total) {
1611 name_len = btrfs_inode_extref_name_len(eb, extref);
1612 index = btrfs_inode_extref_index(eb, extref);
1613 parent = btrfs_inode_extref_parent(eb, extref);
1614 if (name_len <= BTRFS_NAME_LEN) {
1618 len = BTRFS_NAME_LEN;
1619 error = REF_ERR_NAME_TOO_LONG;
1621 read_extent_buffer(eb, namebuf,
1622 (unsigned long)(extref + 1), len);
1623 add_inode_backref(inode_cache, key->objectid, parent,
1624 index, namebuf, len, 0, key->type, error);
1626 len = sizeof(*extref) + name_len;
1627 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1634 static int count_csum_range(struct btrfs_root *root, u64 start,
1635 u64 len, u64 *found)
1637 struct btrfs_key key;
1638 struct btrfs_path path;
1639 struct extent_buffer *leaf;
1644 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1646 btrfs_init_path(&path);
1648 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1650 key.type = BTRFS_EXTENT_CSUM_KEY;
1652 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1656 if (ret > 0 && path.slots[0] > 0) {
1657 leaf = path.nodes[0];
1658 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1659 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1660 key.type == BTRFS_EXTENT_CSUM_KEY)
1665 leaf = path.nodes[0];
1666 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1667 ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1672 leaf = path.nodes[0];
1675 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1676 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1677 key.type != BTRFS_EXTENT_CSUM_KEY)
1680 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1681 if (key.offset >= start + len)
1684 if (key.offset > start)
1687 size = btrfs_item_size_nr(leaf, path.slots[0]);
1688 csum_end = key.offset + (size / csum_size) * root->sectorsize;
1689 if (csum_end > start) {
1690 size = min(csum_end - start, len);
1699 btrfs_release_path(&path);
1705 static int process_file_extent(struct btrfs_root *root,
1706 struct extent_buffer *eb,
1707 int slot, struct btrfs_key *key,
1708 struct shared_node *active_node)
1710 struct inode_record *rec;
1711 struct btrfs_file_extent_item *fi;
1713 u64 disk_bytenr = 0;
1714 u64 extent_offset = 0;
1715 u64 mask = root->sectorsize - 1;
1719 rec = active_node->current;
1720 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1721 rec->found_file_extent = 1;
1723 if (rec->extent_start == (u64)-1) {
1724 rec->extent_start = key->offset;
1725 rec->extent_end = key->offset;
1728 if (rec->extent_end > key->offset)
1729 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1730 else if (rec->extent_end < key->offset) {
1731 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1732 key->offset - rec->extent_end);
1737 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1738 extent_type = btrfs_file_extent_type(eb, fi);
1740 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1741 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1743 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1744 rec->found_size += num_bytes;
1745 num_bytes = (num_bytes + mask) & ~mask;
1746 } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1747 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1748 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1749 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1750 extent_offset = btrfs_file_extent_offset(eb, fi);
1751 if (num_bytes == 0 || (num_bytes & mask))
1752 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1753 if (num_bytes + extent_offset >
1754 btrfs_file_extent_ram_bytes(eb, fi))
1755 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1756 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1757 (btrfs_file_extent_compression(eb, fi) ||
1758 btrfs_file_extent_encryption(eb, fi) ||
1759 btrfs_file_extent_other_encoding(eb, fi)))
1760 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1761 if (disk_bytenr > 0)
1762 rec->found_size += num_bytes;
1764 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1766 rec->extent_end = key->offset + num_bytes;
1769 * The data reloc tree will copy full extents into its inode and then
1770 * copy the corresponding csums. Because the extent it copied could be
1771 * a preallocated extent that hasn't been written to yet there may be no
1772 * csums to copy, ergo we won't have csums for our file extent. This is
1773 * ok so just don't bother checking csums if the inode belongs to the
1776 if (disk_bytenr > 0 &&
1777 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1779 if (btrfs_file_extent_compression(eb, fi))
1780 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1782 disk_bytenr += extent_offset;
1784 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1787 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1789 rec->found_csum_item = 1;
1790 if (found < num_bytes)
1791 rec->some_csum_missing = 1;
1792 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1794 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1800 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1801 struct walk_control *wc)
1803 struct btrfs_key key;
1807 struct cache_tree *inode_cache;
1808 struct shared_node *active_node;
1810 if (wc->root_level == wc->active_node &&
1811 btrfs_root_refs(&root->root_item) == 0)
1814 active_node = wc->nodes[wc->active_node];
1815 inode_cache = &active_node->inode_cache;
1816 nritems = btrfs_header_nritems(eb);
1817 for (i = 0; i < nritems; i++) {
1818 btrfs_item_key_to_cpu(eb, &key, i);
1820 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1822 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1825 if (active_node->current == NULL ||
1826 active_node->current->ino < key.objectid) {
1827 if (active_node->current) {
1828 active_node->current->checked = 1;
1829 maybe_free_inode_rec(inode_cache,
1830 active_node->current);
1832 active_node->current = get_inode_rec(inode_cache,
1834 BUG_ON(IS_ERR(active_node->current));
1837 case BTRFS_DIR_ITEM_KEY:
1838 case BTRFS_DIR_INDEX_KEY:
1839 ret = process_dir_item(root, eb, i, &key, active_node);
1841 case BTRFS_INODE_REF_KEY:
1842 ret = process_inode_ref(eb, i, &key, active_node);
1844 case BTRFS_INODE_EXTREF_KEY:
1845 ret = process_inode_extref(eb, i, &key, active_node);
1847 case BTRFS_INODE_ITEM_KEY:
1848 ret = process_inode_item(eb, i, &key, active_node);
1850 case BTRFS_EXTENT_DATA_KEY:
1851 ret = process_file_extent(root, eb, i, &key,
1862 u64 bytenr[BTRFS_MAX_LEVEL];
1863 u64 refs[BTRFS_MAX_LEVEL];
1864 int need_check[BTRFS_MAX_LEVEL];
1867 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
1868 struct node_refs *nrefs, u64 level);
1869 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1870 unsigned int ext_ref);
1872 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
1873 struct node_refs *nrefs, int *level, int ext_ref)
1875 struct extent_buffer *cur = path->nodes[0];
1876 struct btrfs_key key;
1880 int root_level = btrfs_header_level(root->node);
1882 int ret = 0; /* Final return value */
1883 int err = 0; /* Positive error bitmap */
1885 cur_bytenr = cur->start;
1887 /* skip to first inode item or the first inode number change */
1888 nritems = btrfs_header_nritems(cur);
1889 for (i = 0; i < nritems; i++) {
1890 btrfs_item_key_to_cpu(cur, &key, i);
1892 first_ino = key.objectid;
1893 if (key.type == BTRFS_INODE_ITEM_KEY ||
1894 (first_ino && first_ino != key.objectid))
1898 path->slots[0] = nritems;
1904 err |= check_inode_item(root, path, ext_ref);
1906 if (err & LAST_ITEM)
1909 /* still have inode items in thie leaf */
1910 if (cur->start == cur_bytenr)
1914 * we have switched to another leaf, above nodes may
1915 * have changed, here walk down the path, if a node
1916 * or leaf is shared, check whether we can skip this
1919 for (i = root_level; i >= 0; i--) {
1920 if (path->nodes[i]->start == nrefs->bytenr[i])
1923 ret = update_nodes_refs(root,
1924 path->nodes[i]->start,
1929 if (!nrefs->need_check[i]) {
1935 for (i = 0; i < *level; i++) {
1936 free_extent_buffer(path->nodes[i]);
1937 path->nodes[i] = NULL;
1942 * Convert any error bitmap to -EIO, as we should avoid
1943 * mixing positive and negative return value to represent
1951 static void reada_walk_down(struct btrfs_root *root,
1952 struct extent_buffer *node, int slot)
1961 level = btrfs_header_level(node);
1965 nritems = btrfs_header_nritems(node);
1966 blocksize = root->nodesize;
1967 for (i = slot; i < nritems; i++) {
1968 bytenr = btrfs_node_blockptr(node, i);
1969 ptr_gen = btrfs_node_ptr_generation(node, i);
1970 readahead_tree_block(root, bytenr, blocksize, ptr_gen);
1975 * Check the child node/leaf by the following condition:
1976 * 1. the first item key of the node/leaf should be the same with the one
1978 * 2. block in parent node should match the child node/leaf.
1979 * 3. generation of parent node and child's header should be consistent.
1981 * Or the child node/leaf pointed by the key in parent is not valid.
1983 * We hope to check leaf owner too, but since subvol may share leaves,
1984 * which makes leaf owner check not so strong, key check should be
1985 * sufficient enough for that case.
1987 static int check_child_node(struct btrfs_root *root,
1988 struct extent_buffer *parent, int slot,
1989 struct extent_buffer *child)
1991 struct btrfs_key parent_key;
1992 struct btrfs_key child_key;
1995 btrfs_node_key_to_cpu(parent, &parent_key, slot);
1996 if (btrfs_header_level(child) == 0)
1997 btrfs_item_key_to_cpu(child, &child_key, 0);
1999 btrfs_node_key_to_cpu(child, &child_key, 0);
2001 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2004 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2005 parent_key.objectid, parent_key.type, parent_key.offset,
2006 child_key.objectid, child_key.type, child_key.offset);
2008 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2010 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2011 btrfs_node_blockptr(parent, slot),
2012 btrfs_header_bytenr(child));
2014 if (btrfs_node_ptr_generation(parent, slot) !=
2015 btrfs_header_generation(child)) {
2017 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2018 btrfs_header_generation(child),
2019 btrfs_node_ptr_generation(parent, slot));
2025 * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2026 * in every fs or file tree check. Here we find its all root ids, and only check
2027 * it in the fs or file tree which has the smallest root id.
2029 static int need_check(struct btrfs_root *root, struct ulist *roots)
2031 struct rb_node *node;
2032 struct ulist_node *u;
2034 if (roots->nnodes == 1)
2037 node = rb_first(&roots->root);
2038 u = rb_entry(node, struct ulist_node, rb_node);
2040 * current root id is not smallest, we skip it and let it be checked
2041 * in the fs or file tree who hash the smallest root id.
2043 if (root->objectid != u->val)
2050 * for a tree node or leaf, we record its reference count, so later if we still
2051 * process this node or leaf, don't need to compute its reference count again.
2053 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2054 struct node_refs *nrefs, u64 level)
2058 struct ulist *roots;
2060 if (nrefs->bytenr[level] != bytenr) {
2061 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2062 level, 1, &refs, NULL);
2066 nrefs->bytenr[level] = bytenr;
2067 nrefs->refs[level] = refs;
2069 ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2074 check = need_check(root, roots);
2076 nrefs->need_check[level] = check;
2078 nrefs->need_check[level] = 1;
2085 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2086 struct walk_control *wc, int *level,
2087 struct node_refs *nrefs)
2089 enum btrfs_tree_block_status status;
2092 struct extent_buffer *next;
2093 struct extent_buffer *cur;
2098 WARN_ON(*level < 0);
2099 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2101 if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2102 refs = nrefs->refs[*level];
2105 ret = btrfs_lookup_extent_info(NULL, root,
2106 path->nodes[*level]->start,
2107 *level, 1, &refs, NULL);
2112 nrefs->bytenr[*level] = path->nodes[*level]->start;
2113 nrefs->refs[*level] = refs;
2117 ret = enter_shared_node(root, path->nodes[*level]->start,
2125 while (*level >= 0) {
2126 WARN_ON(*level < 0);
2127 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2128 cur = path->nodes[*level];
2130 if (btrfs_header_level(cur) != *level)
2133 if (path->slots[*level] >= btrfs_header_nritems(cur))
2136 ret = process_one_leaf(root, cur, wc);
2141 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2142 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2143 blocksize = root->nodesize;
2145 if (bytenr == nrefs->bytenr[*level - 1]) {
2146 refs = nrefs->refs[*level - 1];
2148 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2149 *level - 1, 1, &refs, NULL);
2153 nrefs->bytenr[*level - 1] = bytenr;
2154 nrefs->refs[*level - 1] = refs;
2159 ret = enter_shared_node(root, bytenr, refs,
2162 path->slots[*level]++;
2167 next = btrfs_find_tree_block(root, bytenr, blocksize);
2168 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2169 free_extent_buffer(next);
2170 reada_walk_down(root, cur, path->slots[*level]);
2171 next = read_tree_block(root, bytenr, blocksize,
2173 if (!extent_buffer_uptodate(next)) {
2174 struct btrfs_key node_key;
2176 btrfs_node_key_to_cpu(path->nodes[*level],
2178 path->slots[*level]);
2179 btrfs_add_corrupt_extent_record(root->fs_info,
2181 path->nodes[*level]->start,
2182 root->nodesize, *level);
2188 ret = check_child_node(root, cur, path->slots[*level], next);
2194 if (btrfs_is_leaf(next))
2195 status = btrfs_check_leaf(root, NULL, next);
2197 status = btrfs_check_node(root, NULL, next);
2198 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2199 free_extent_buffer(next);
2204 *level = *level - 1;
2205 free_extent_buffer(path->nodes[*level]);
2206 path->nodes[*level] = next;
2207 path->slots[*level] = 0;
2210 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2214 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2215 unsigned int ext_ref);
2217 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2218 int *level, struct node_refs *nrefs, int ext_ref)
2220 enum btrfs_tree_block_status status;
2223 struct extent_buffer *next;
2224 struct extent_buffer *cur;
2228 WARN_ON(*level < 0);
2229 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2231 ret = update_nodes_refs(root, path->nodes[*level]->start,
2236 while (*level >= 0) {
2237 WARN_ON(*level < 0);
2238 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2239 cur = path->nodes[*level];
2241 if (btrfs_header_level(cur) != *level)
2244 if (path->slots[*level] >= btrfs_header_nritems(cur))
2246 /* Don't forgot to check leaf/node validation */
2248 ret = btrfs_check_leaf(root, NULL, cur);
2249 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2253 ret = process_one_leaf_v2(root, path, nrefs,
2257 ret = btrfs_check_node(root, NULL, cur);
2258 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2263 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2264 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2265 blocksize = root->nodesize;
2267 ret = update_nodes_refs(root, bytenr, nrefs, *level - 1);
2270 if (!nrefs->need_check[*level - 1]) {
2271 path->slots[*level]++;
2275 next = btrfs_find_tree_block(root, bytenr, blocksize);
2276 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2277 free_extent_buffer(next);
2278 reada_walk_down(root, cur, path->slots[*level]);
2279 next = read_tree_block(root, bytenr, blocksize,
2281 if (!extent_buffer_uptodate(next)) {
2282 struct btrfs_key node_key;
2284 btrfs_node_key_to_cpu(path->nodes[*level],
2286 path->slots[*level]);
2287 btrfs_add_corrupt_extent_record(root->fs_info,
2289 path->nodes[*level]->start,
2290 root->nodesize, *level);
2296 ret = check_child_node(root, cur, path->slots[*level], next);
2300 if (btrfs_is_leaf(next))
2301 status = btrfs_check_leaf(root, NULL, next);
2303 status = btrfs_check_node(root, NULL, next);
2304 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2305 free_extent_buffer(next);
2310 *level = *level - 1;
2311 free_extent_buffer(path->nodes[*level]);
2312 path->nodes[*level] = next;
2313 path->slots[*level] = 0;
2318 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2319 struct walk_control *wc, int *level)
2322 struct extent_buffer *leaf;
2324 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2325 leaf = path->nodes[i];
2326 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2331 free_extent_buffer(path->nodes[*level]);
2332 path->nodes[*level] = NULL;
2333 BUG_ON(*level > wc->active_node);
2334 if (*level == wc->active_node)
2335 leave_shared_node(root, wc, *level);
2342 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2346 struct extent_buffer *leaf;
2348 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2349 leaf = path->nodes[i];
2350 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2355 free_extent_buffer(path->nodes[*level]);
2356 path->nodes[*level] = NULL;
2363 static int check_root_dir(struct inode_record *rec)
2365 struct inode_backref *backref;
2368 if (!rec->found_inode_item || rec->errors)
2370 if (rec->nlink != 1 || rec->found_link != 0)
2372 if (list_empty(&rec->backrefs))
2374 backref = to_inode_backref(rec->backrefs.next);
2375 if (!backref->found_inode_ref)
2377 if (backref->index != 0 || backref->namelen != 2 ||
2378 memcmp(backref->name, "..", 2))
2380 if (backref->found_dir_index || backref->found_dir_item)
2387 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2388 struct btrfs_root *root, struct btrfs_path *path,
2389 struct inode_record *rec)
2391 struct btrfs_inode_item *ei;
2392 struct btrfs_key key;
2395 key.objectid = rec->ino;
2396 key.type = BTRFS_INODE_ITEM_KEY;
2397 key.offset = (u64)-1;
2399 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2403 if (!path->slots[0]) {
2410 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2411 if (key.objectid != rec->ino) {
2416 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2417 struct btrfs_inode_item);
2418 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2419 btrfs_mark_buffer_dirty(path->nodes[0]);
2420 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2421 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2422 root->root_key.objectid);
2424 btrfs_release_path(path);
2428 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2429 struct btrfs_root *root,
2430 struct btrfs_path *path,
2431 struct inode_record *rec)
2435 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2436 btrfs_release_path(path);
2438 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2442 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2443 struct btrfs_root *root,
2444 struct btrfs_path *path,
2445 struct inode_record *rec)
2447 struct btrfs_inode_item *ei;
2448 struct btrfs_key key;
2451 key.objectid = rec->ino;
2452 key.type = BTRFS_INODE_ITEM_KEY;
2455 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2462 /* Since ret == 0, no need to check anything */
2463 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2464 struct btrfs_inode_item);
2465 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2466 btrfs_mark_buffer_dirty(path->nodes[0]);
2467 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2468 printf("reset nbytes for ino %llu root %llu\n",
2469 rec->ino, root->root_key.objectid);
2471 btrfs_release_path(path);
2475 static int add_missing_dir_index(struct btrfs_root *root,
2476 struct cache_tree *inode_cache,
2477 struct inode_record *rec,
2478 struct inode_backref *backref)
2480 struct btrfs_path path;
2481 struct btrfs_trans_handle *trans;
2482 struct btrfs_dir_item *dir_item;
2483 struct extent_buffer *leaf;
2484 struct btrfs_key key;
2485 struct btrfs_disk_key disk_key;
2486 struct inode_record *dir_rec;
2487 unsigned long name_ptr;
2488 u32 data_size = sizeof(*dir_item) + backref->namelen;
2491 trans = btrfs_start_transaction(root, 1);
2493 return PTR_ERR(trans);
2495 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2496 (unsigned long long)rec->ino);
2498 btrfs_init_path(&path);
2499 key.objectid = backref->dir;
2500 key.type = BTRFS_DIR_INDEX_KEY;
2501 key.offset = backref->index;
2502 ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
2505 leaf = path.nodes[0];
2506 dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
2508 disk_key.objectid = cpu_to_le64(rec->ino);
2509 disk_key.type = BTRFS_INODE_ITEM_KEY;
2510 disk_key.offset = 0;
2512 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2513 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2514 btrfs_set_dir_data_len(leaf, dir_item, 0);
2515 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2516 name_ptr = (unsigned long)(dir_item + 1);
2517 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2518 btrfs_mark_buffer_dirty(leaf);
2519 btrfs_release_path(&path);
2520 btrfs_commit_transaction(trans, root);
2522 backref->found_dir_index = 1;
2523 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2524 BUG_ON(IS_ERR(dir_rec));
2527 dir_rec->found_size += backref->namelen;
2528 if (dir_rec->found_size == dir_rec->isize &&
2529 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2530 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2531 if (dir_rec->found_size != dir_rec->isize)
2532 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2537 static int delete_dir_index(struct btrfs_root *root,
2538 struct cache_tree *inode_cache,
2539 struct inode_record *rec,
2540 struct inode_backref *backref)
2542 struct btrfs_trans_handle *trans;
2543 struct btrfs_dir_item *di;
2544 struct btrfs_path path;
2547 trans = btrfs_start_transaction(root, 1);
2549 return PTR_ERR(trans);
2551 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2552 (unsigned long long)backref->dir,
2553 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2554 (unsigned long long)root->objectid);
2556 btrfs_init_path(&path);
2557 di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
2558 backref->name, backref->namelen,
2559 backref->index, -1);
2562 btrfs_release_path(&path);
2563 btrfs_commit_transaction(trans, root);
2570 ret = btrfs_del_item(trans, root, &path);
2572 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
2574 btrfs_release_path(&path);
2575 btrfs_commit_transaction(trans, root);
2579 static int create_inode_item(struct btrfs_root *root,
2580 struct inode_record *rec,
2581 struct inode_backref *backref, int root_dir)
2583 struct btrfs_trans_handle *trans;
2584 struct btrfs_inode_item inode_item;
2585 time_t now = time(NULL);
2588 trans = btrfs_start_transaction(root, 1);
2589 if (IS_ERR(trans)) {
2590 ret = PTR_ERR(trans);
2594 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2595 "be incomplete, please check permissions and content after "
2596 "the fsck completes.\n", (unsigned long long)root->objectid,
2597 (unsigned long long)rec->ino);
2599 memset(&inode_item, 0, sizeof(inode_item));
2600 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2602 btrfs_set_stack_inode_nlink(&inode_item, 1);
2604 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2605 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2606 if (rec->found_dir_item) {
2607 if (rec->found_file_extent)
2608 fprintf(stderr, "root %llu inode %llu has both a dir "
2609 "item and extents, unsure if it is a dir or a "
2610 "regular file so setting it as a directory\n",
2611 (unsigned long long)root->objectid,
2612 (unsigned long long)rec->ino);
2613 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2614 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2615 } else if (!rec->found_dir_item) {
2616 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2617 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2619 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2620 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2621 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2622 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2623 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2624 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2625 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2626 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2628 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2630 btrfs_commit_transaction(trans, root);
2634 static int repair_inode_backrefs(struct btrfs_root *root,
2635 struct inode_record *rec,
2636 struct cache_tree *inode_cache,
2639 struct inode_backref *tmp, *backref;
2640 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2644 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2645 if (!delete && rec->ino == root_dirid) {
2646 if (!rec->found_inode_item) {
2647 ret = create_inode_item(root, rec, backref, 1);
2654 /* Index 0 for root dir's are special, don't mess with it */
2655 if (rec->ino == root_dirid && backref->index == 0)
2659 ((backref->found_dir_index && !backref->found_inode_ref) ||
2660 (backref->found_dir_index && backref->found_inode_ref &&
2661 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2662 ret = delete_dir_index(root, inode_cache, rec, backref);
2666 list_del(&backref->list);
2670 if (!delete && !backref->found_dir_index &&
2671 backref->found_dir_item && backref->found_inode_ref) {
2672 ret = add_missing_dir_index(root, inode_cache, rec,
2677 if (backref->found_dir_item &&
2678 backref->found_dir_index &&
2679 backref->found_dir_index) {
2680 if (!backref->errors &&
2681 backref->found_inode_ref) {
2682 list_del(&backref->list);
2688 if (!delete && (!backref->found_dir_index &&
2689 !backref->found_dir_item &&
2690 backref->found_inode_ref)) {
2691 struct btrfs_trans_handle *trans;
2692 struct btrfs_key location;
2694 ret = check_dir_conflict(root, backref->name,
2700 * let nlink fixing routine to handle it,
2701 * which can do it better.
2706 location.objectid = rec->ino;
2707 location.type = BTRFS_INODE_ITEM_KEY;
2708 location.offset = 0;
2710 trans = btrfs_start_transaction(root, 1);
2711 if (IS_ERR(trans)) {
2712 ret = PTR_ERR(trans);
2715 fprintf(stderr, "adding missing dir index/item pair "
2717 (unsigned long long)rec->ino);
2718 ret = btrfs_insert_dir_item(trans, root, backref->name,
2720 backref->dir, &location,
2721 imode_to_type(rec->imode),
2724 btrfs_commit_transaction(trans, root);
2728 if (!delete && (backref->found_inode_ref &&
2729 backref->found_dir_index &&
2730 backref->found_dir_item &&
2731 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2732 !rec->found_inode_item)) {
2733 ret = create_inode_item(root, rec, backref, 0);
2740 return ret ? ret : repaired;
2744 * To determine the file type for nlink/inode_item repair
2746 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2747 * Return -ENOENT if file type is not found.
2749 static int find_file_type(struct inode_record *rec, u8 *type)
2751 struct inode_backref *backref;
2753 /* For inode item recovered case */
2754 if (rec->found_inode_item) {
2755 *type = imode_to_type(rec->imode);
2759 list_for_each_entry(backref, &rec->backrefs, list) {
2760 if (backref->found_dir_index || backref->found_dir_item) {
2761 *type = backref->filetype;
2769 * To determine the file name for nlink repair
2771 * Return 0 if file name is found, set name and namelen.
2772 * Return -ENOENT if file name is not found.
2774 static int find_file_name(struct inode_record *rec,
2775 char *name, int *namelen)
2777 struct inode_backref *backref;
2779 list_for_each_entry(backref, &rec->backrefs, list) {
2780 if (backref->found_dir_index || backref->found_dir_item ||
2781 backref->found_inode_ref) {
2782 memcpy(name, backref->name, backref->namelen);
2783 *namelen = backref->namelen;
2790 /* Reset the nlink of the inode to the correct one */
2791 static int reset_nlink(struct btrfs_trans_handle *trans,
2792 struct btrfs_root *root,
2793 struct btrfs_path *path,
2794 struct inode_record *rec)
2796 struct inode_backref *backref;
2797 struct inode_backref *tmp;
2798 struct btrfs_key key;
2799 struct btrfs_inode_item *inode_item;
2802 /* We don't believe this either, reset it and iterate backref */
2803 rec->found_link = 0;
2805 /* Remove all backref including the valid ones */
2806 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2807 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2808 backref->index, backref->name,
2809 backref->namelen, 0);
2813 /* remove invalid backref, so it won't be added back */
2814 if (!(backref->found_dir_index &&
2815 backref->found_dir_item &&
2816 backref->found_inode_ref)) {
2817 list_del(&backref->list);
2824 /* Set nlink to 0 */
2825 key.objectid = rec->ino;
2826 key.type = BTRFS_INODE_ITEM_KEY;
2828 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2835 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2836 struct btrfs_inode_item);
2837 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2838 btrfs_mark_buffer_dirty(path->nodes[0]);
2839 btrfs_release_path(path);
2842 * Add back valid inode_ref/dir_item/dir_index,
2843 * add_link() will handle the nlink inc, so new nlink must be correct
2845 list_for_each_entry(backref, &rec->backrefs, list) {
2846 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2847 backref->name, backref->namelen,
2848 backref->filetype, &backref->index, 1);
2853 btrfs_release_path(path);
2857 static int get_highest_inode(struct btrfs_trans_handle *trans,
2858 struct btrfs_root *root,
2859 struct btrfs_path *path,
2862 struct btrfs_key key, found_key;
2865 btrfs_init_path(path);
2866 key.objectid = BTRFS_LAST_FREE_OBJECTID;
2868 key.type = BTRFS_INODE_ITEM_KEY;
2869 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2871 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2872 path->slots[0] - 1);
2873 *highest_ino = found_key.objectid;
2876 if (*highest_ino >= BTRFS_LAST_FREE_OBJECTID)
2878 btrfs_release_path(path);
2882 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2883 struct btrfs_root *root,
2884 struct btrfs_path *path,
2885 struct inode_record *rec)
2887 char *dir_name = "lost+found";
2888 char namebuf[BTRFS_NAME_LEN] = {0};
2893 int name_recovered = 0;
2894 int type_recovered = 0;
2898 * Get file name and type first before these invalid inode ref
2899 * are deleted by remove_all_invalid_backref()
2901 name_recovered = !find_file_name(rec, namebuf, &namelen);
2902 type_recovered = !find_file_type(rec, &type);
2904 if (!name_recovered) {
2905 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2906 rec->ino, rec->ino);
2907 namelen = count_digits(rec->ino);
2908 sprintf(namebuf, "%llu", rec->ino);
2911 if (!type_recovered) {
2912 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2914 type = BTRFS_FT_REG_FILE;
2918 ret = reset_nlink(trans, root, path, rec);
2921 "Failed to reset nlink for inode %llu: %s\n",
2922 rec->ino, strerror(-ret));
2926 if (rec->found_link == 0) {
2927 ret = get_highest_inode(trans, root, path, &lost_found_ino);
2931 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2932 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2935 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2936 dir_name, strerror(-ret));
2939 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2940 namebuf, namelen, type, NULL, 1);
2942 * Add ".INO" suffix several times to handle case where
2943 * "FILENAME.INO" is already taken by another file.
2945 while (ret == -EEXIST) {
2947 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2949 if (namelen + count_digits(rec->ino) + 1 >
2954 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2956 namelen += count_digits(rec->ino) + 1;
2957 ret = btrfs_add_link(trans, root, rec->ino,
2958 lost_found_ino, namebuf,
2959 namelen, type, NULL, 1);
2963 "Failed to link the inode %llu to %s dir: %s\n",
2964 rec->ino, dir_name, strerror(-ret));
2968 * Just increase the found_link, don't actually add the
2969 * backref. This will make things easier and this inode
2970 * record will be freed after the repair is done.
2971 * So fsck will not report problem about this inode.
2974 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2975 namelen, namebuf, dir_name);
2977 printf("Fixed the nlink of inode %llu\n", rec->ino);
2980 * Clear the flag anyway, or we will loop forever for the same inode
2981 * as it will not be removed from the bad inode list and the dead loop
2984 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2985 btrfs_release_path(path);
2990 * Check if there is any normal(reg or prealloc) file extent for given
2992 * This is used to determine the file type when neither its dir_index/item or
2993 * inode_item exists.
2995 * This will *NOT* report error, if any error happens, just consider it does
2996 * not have any normal file extent.
2998 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
3000 struct btrfs_path path;
3001 struct btrfs_key key;
3002 struct btrfs_key found_key;
3003 struct btrfs_file_extent_item *fi;
3007 btrfs_init_path(&path);
3009 key.type = BTRFS_EXTENT_DATA_KEY;
3012 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3017 if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
3018 ret = btrfs_next_leaf(root, &path);
3025 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3027 if (found_key.objectid != ino ||
3028 found_key.type != BTRFS_EXTENT_DATA_KEY)
3030 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3031 struct btrfs_file_extent_item);
3032 type = btrfs_file_extent_type(path.nodes[0], fi);
3033 if (type != BTRFS_FILE_EXTENT_INLINE) {
3039 btrfs_release_path(&path);
3043 static u32 btrfs_type_to_imode(u8 type)
3045 static u32 imode_by_btrfs_type[] = {
3046 [BTRFS_FT_REG_FILE] = S_IFREG,
3047 [BTRFS_FT_DIR] = S_IFDIR,
3048 [BTRFS_FT_CHRDEV] = S_IFCHR,
3049 [BTRFS_FT_BLKDEV] = S_IFBLK,
3050 [BTRFS_FT_FIFO] = S_IFIFO,
3051 [BTRFS_FT_SOCK] = S_IFSOCK,
3052 [BTRFS_FT_SYMLINK] = S_IFLNK,
3055 return imode_by_btrfs_type[(type)];
3058 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3059 struct btrfs_root *root,
3060 struct btrfs_path *path,
3061 struct inode_record *rec)
3065 int type_recovered = 0;
3068 printf("Trying to rebuild inode:%llu\n", rec->ino);
3070 type_recovered = !find_file_type(rec, &filetype);
3073 * Try to determine inode type if type not found.
3075 * For found regular file extent, it must be FILE.
3076 * For found dir_item/index, it must be DIR.
3078 * For undetermined one, use FILE as fallback.
3081 * 1. If found backref(inode_index/item is already handled) to it,
3083 * Need new inode-inode ref structure to allow search for that.
3085 if (!type_recovered) {
3086 if (rec->found_file_extent &&
3087 find_normal_file_extent(root, rec->ino)) {
3089 filetype = BTRFS_FT_REG_FILE;
3090 } else if (rec->found_dir_item) {
3092 filetype = BTRFS_FT_DIR;
3093 } else if (!list_empty(&rec->orphan_extents)) {
3095 filetype = BTRFS_FT_REG_FILE;
3097 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3100 filetype = BTRFS_FT_REG_FILE;
3104 ret = btrfs_new_inode(trans, root, rec->ino,
3105 mode | btrfs_type_to_imode(filetype));
3110 * Here inode rebuild is done, we only rebuild the inode item,
3111 * don't repair the nlink(like move to lost+found).
3112 * That is the job of nlink repair.
3114 * We just fill the record and return
3116 rec->found_dir_item = 1;
3117 rec->imode = mode | btrfs_type_to_imode(filetype);
3119 rec->errors &= ~I_ERR_NO_INODE_ITEM;
3120 /* Ensure the inode_nlinks repair function will be called */
3121 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3126 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3127 struct btrfs_root *root,
3128 struct btrfs_path *path,
3129 struct inode_record *rec)
3131 struct orphan_data_extent *orphan;
3132 struct orphan_data_extent *tmp;
3135 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3137 * Check for conflicting file extents
3139 * Here we don't know whether the extents is compressed or not,
3140 * so we can only assume it not compressed nor data offset,
3141 * and use its disk_len as extent length.
3143 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3144 orphan->offset, orphan->disk_len, 0);
3145 btrfs_release_path(path);
3150 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3151 orphan->disk_bytenr, orphan->disk_len);
3152 ret = btrfs_free_extent(trans,
3153 root->fs_info->extent_root,
3154 orphan->disk_bytenr, orphan->disk_len,
3155 0, root->objectid, orphan->objectid,
3160 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3161 orphan->offset, orphan->disk_bytenr,
3162 orphan->disk_len, orphan->disk_len);
3166 /* Update file size info */
3167 rec->found_size += orphan->disk_len;
3168 if (rec->found_size == rec->nbytes)
3169 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3171 /* Update the file extent hole info too */
3172 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3176 if (RB_EMPTY_ROOT(&rec->holes))
3177 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3179 list_del(&orphan->list);
3182 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3187 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3188 struct btrfs_root *root,
3189 struct btrfs_path *path,
3190 struct inode_record *rec)
3192 struct rb_node *node;
3193 struct file_extent_hole *hole;
3197 node = rb_first(&rec->holes);
3201 hole = rb_entry(node, struct file_extent_hole, node);
3202 ret = btrfs_punch_hole(trans, root, rec->ino,
3203 hole->start, hole->len);
3206 ret = del_file_extent_hole(&rec->holes, hole->start,
3210 if (RB_EMPTY_ROOT(&rec->holes))
3211 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3212 node = rb_first(&rec->holes);
3214 /* special case for a file losing all its file extent */
3216 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3217 round_up(rec->isize, root->sectorsize));
3221 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3222 rec->ino, root->objectid);
3227 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3229 struct btrfs_trans_handle *trans;
3230 struct btrfs_path path;
3233 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3234 I_ERR_NO_ORPHAN_ITEM |
3235 I_ERR_LINK_COUNT_WRONG |
3236 I_ERR_NO_INODE_ITEM |
3237 I_ERR_FILE_EXTENT_ORPHAN |
3238 I_ERR_FILE_EXTENT_DISCOUNT|
3239 I_ERR_FILE_NBYTES_WRONG)))
3243 * For nlink repair, it may create a dir and add link, so
3244 * 2 for parent(256)'s dir_index and dir_item
3245 * 2 for lost+found dir's inode_item and inode_ref
3246 * 1 for the new inode_ref of the file
3247 * 2 for lost+found dir's dir_index and dir_item for the file
3249 trans = btrfs_start_transaction(root, 7);
3251 return PTR_ERR(trans);
3253 btrfs_init_path(&path);
3254 if (rec->errors & I_ERR_NO_INODE_ITEM)
3255 ret = repair_inode_no_item(trans, root, &path, rec);
3256 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3257 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3258 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3259 ret = repair_inode_discount_extent(trans, root, &path, rec);
3260 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3261 ret = repair_inode_isize(trans, root, &path, rec);
3262 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3263 ret = repair_inode_orphan_item(trans, root, &path, rec);
3264 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3265 ret = repair_inode_nlinks(trans, root, &path, rec);
3266 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3267 ret = repair_inode_nbytes(trans, root, &path, rec);
3268 btrfs_commit_transaction(trans, root);
3269 btrfs_release_path(&path);
3273 static int check_inode_recs(struct btrfs_root *root,
3274 struct cache_tree *inode_cache)
3276 struct cache_extent *cache;
3277 struct ptr_node *node;
3278 struct inode_record *rec;
3279 struct inode_backref *backref;
3284 u64 root_dirid = btrfs_root_dirid(&root->root_item);
3286 if (btrfs_root_refs(&root->root_item) == 0) {
3287 if (!cache_tree_empty(inode_cache))
3288 fprintf(stderr, "warning line %d\n", __LINE__);
3293 * We need to repair backrefs first because we could change some of the
3294 * errors in the inode recs.
3296 * We also need to go through and delete invalid backrefs first and then
3297 * add the correct ones second. We do this because we may get EEXIST
3298 * when adding back the correct index because we hadn't yet deleted the
3301 * For example, if we were missing a dir index then the directories
3302 * isize would be wrong, so if we fixed the isize to what we thought it
3303 * would be and then fixed the backref we'd still have a invalid fs, so
3304 * we need to add back the dir index and then check to see if the isize
3309 if (stage == 3 && !err)
3312 cache = search_cache_extent(inode_cache, 0);
3313 while (repair && cache) {
3314 node = container_of(cache, struct ptr_node, cache);
3316 cache = next_cache_extent(cache);
3318 /* Need to free everything up and rescan */
3320 remove_cache_extent(inode_cache, &node->cache);
3322 free_inode_rec(rec);
3326 if (list_empty(&rec->backrefs))
3329 ret = repair_inode_backrefs(root, rec, inode_cache,
3343 rec = get_inode_rec(inode_cache, root_dirid, 0);
3344 BUG_ON(IS_ERR(rec));
3346 ret = check_root_dir(rec);
3348 fprintf(stderr, "root %llu root dir %llu error\n",
3349 (unsigned long long)root->root_key.objectid,
3350 (unsigned long long)root_dirid);
3351 print_inode_error(root, rec);
3356 struct btrfs_trans_handle *trans;
3358 trans = btrfs_start_transaction(root, 1);
3359 if (IS_ERR(trans)) {
3360 err = PTR_ERR(trans);
3365 "root %llu missing its root dir, recreating\n",
3366 (unsigned long long)root->objectid);
3368 ret = btrfs_make_root_dir(trans, root, root_dirid);
3371 btrfs_commit_transaction(trans, root);
3375 fprintf(stderr, "root %llu root dir %llu not found\n",
3376 (unsigned long long)root->root_key.objectid,
3377 (unsigned long long)root_dirid);
3381 cache = search_cache_extent(inode_cache, 0);
3384 node = container_of(cache, struct ptr_node, cache);
3386 remove_cache_extent(inode_cache, &node->cache);
3388 if (rec->ino == root_dirid ||
3389 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3390 free_inode_rec(rec);
3394 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3395 ret = check_orphan_item(root, rec->ino);
3397 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3398 if (can_free_inode_rec(rec)) {
3399 free_inode_rec(rec);
3404 if (!rec->found_inode_item)
3405 rec->errors |= I_ERR_NO_INODE_ITEM;
3406 if (rec->found_link != rec->nlink)
3407 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3409 ret = try_repair_inode(root, rec);
3410 if (ret == 0 && can_free_inode_rec(rec)) {
3411 free_inode_rec(rec);
3417 if (!(repair && ret == 0))
3419 print_inode_error(root, rec);
3420 list_for_each_entry(backref, &rec->backrefs, list) {
3421 if (!backref->found_dir_item)
3422 backref->errors |= REF_ERR_NO_DIR_ITEM;
3423 if (!backref->found_dir_index)
3424 backref->errors |= REF_ERR_NO_DIR_INDEX;
3425 if (!backref->found_inode_ref)
3426 backref->errors |= REF_ERR_NO_INODE_REF;
3427 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3428 " namelen %u name %s filetype %d errors %x",
3429 (unsigned long long)backref->dir,
3430 (unsigned long long)backref->index,
3431 backref->namelen, backref->name,
3432 backref->filetype, backref->errors);
3433 print_ref_error(backref->errors);
3435 free_inode_rec(rec);
3437 return (error > 0) ? -1 : 0;
3440 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3443 struct cache_extent *cache;
3444 struct root_record *rec = NULL;
3447 cache = lookup_cache_extent(root_cache, objectid, 1);
3449 rec = container_of(cache, struct root_record, cache);
3451 rec = calloc(1, sizeof(*rec));
3453 return ERR_PTR(-ENOMEM);
3454 rec->objectid = objectid;
3455 INIT_LIST_HEAD(&rec->backrefs);
3456 rec->cache.start = objectid;
3457 rec->cache.size = 1;
3459 ret = insert_cache_extent(root_cache, &rec->cache);
3461 return ERR_PTR(-EEXIST);
3466 static struct root_backref *get_root_backref(struct root_record *rec,
3467 u64 ref_root, u64 dir, u64 index,
3468 const char *name, int namelen)
3470 struct root_backref *backref;
3472 list_for_each_entry(backref, &rec->backrefs, list) {
3473 if (backref->ref_root != ref_root || backref->dir != dir ||
3474 backref->namelen != namelen)
3476 if (memcmp(name, backref->name, namelen))
3481 backref = calloc(1, sizeof(*backref) + namelen + 1);
3484 backref->ref_root = ref_root;
3486 backref->index = index;
3487 backref->namelen = namelen;
3488 memcpy(backref->name, name, namelen);
3489 backref->name[namelen] = '\0';
3490 list_add_tail(&backref->list, &rec->backrefs);
3494 static void free_root_record(struct cache_extent *cache)
3496 struct root_record *rec;
3497 struct root_backref *backref;
3499 rec = container_of(cache, struct root_record, cache);
3500 while (!list_empty(&rec->backrefs)) {
3501 backref = to_root_backref(rec->backrefs.next);
3502 list_del(&backref->list);
3509 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3511 static int add_root_backref(struct cache_tree *root_cache,
3512 u64 root_id, u64 ref_root, u64 dir, u64 index,
3513 const char *name, int namelen,
3514 int item_type, int errors)
3516 struct root_record *rec;
3517 struct root_backref *backref;
3519 rec = get_root_rec(root_cache, root_id);
3520 BUG_ON(IS_ERR(rec));
3521 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3524 backref->errors |= errors;
3526 if (item_type != BTRFS_DIR_ITEM_KEY) {
3527 if (backref->found_dir_index || backref->found_back_ref ||
3528 backref->found_forward_ref) {
3529 if (backref->index != index)
3530 backref->errors |= REF_ERR_INDEX_UNMATCH;
3532 backref->index = index;
3536 if (item_type == BTRFS_DIR_ITEM_KEY) {
3537 if (backref->found_forward_ref)
3539 backref->found_dir_item = 1;
3540 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3541 backref->found_dir_index = 1;
3542 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3543 if (backref->found_forward_ref)
3544 backref->errors |= REF_ERR_DUP_ROOT_REF;
3545 else if (backref->found_dir_item)
3547 backref->found_forward_ref = 1;
3548 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3549 if (backref->found_back_ref)
3550 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3551 backref->found_back_ref = 1;
3556 if (backref->found_forward_ref && backref->found_dir_item)
3557 backref->reachable = 1;
3561 static int merge_root_recs(struct btrfs_root *root,
3562 struct cache_tree *src_cache,
3563 struct cache_tree *dst_cache)
3565 struct cache_extent *cache;
3566 struct ptr_node *node;
3567 struct inode_record *rec;
3568 struct inode_backref *backref;
3571 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3572 free_inode_recs_tree(src_cache);
3577 cache = search_cache_extent(src_cache, 0);
3580 node = container_of(cache, struct ptr_node, cache);
3582 remove_cache_extent(src_cache, &node->cache);
3585 ret = is_child_root(root, root->objectid, rec->ino);
3591 list_for_each_entry(backref, &rec->backrefs, list) {
3592 BUG_ON(backref->found_inode_ref);
3593 if (backref->found_dir_item)
3594 add_root_backref(dst_cache, rec->ino,
3595 root->root_key.objectid, backref->dir,
3596 backref->index, backref->name,
3597 backref->namelen, BTRFS_DIR_ITEM_KEY,
3599 if (backref->found_dir_index)
3600 add_root_backref(dst_cache, rec->ino,
3601 root->root_key.objectid, backref->dir,
3602 backref->index, backref->name,
3603 backref->namelen, BTRFS_DIR_INDEX_KEY,
3607 free_inode_rec(rec);
3614 static int check_root_refs(struct btrfs_root *root,
3615 struct cache_tree *root_cache)
3617 struct root_record *rec;
3618 struct root_record *ref_root;
3619 struct root_backref *backref;
3620 struct cache_extent *cache;
3626 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3627 BUG_ON(IS_ERR(rec));
3630 /* fixme: this can not detect circular references */
3633 cache = search_cache_extent(root_cache, 0);
3637 rec = container_of(cache, struct root_record, cache);
3638 cache = next_cache_extent(cache);
3640 if (rec->found_ref == 0)
3643 list_for_each_entry(backref, &rec->backrefs, list) {
3644 if (!backref->reachable)
3647 ref_root = get_root_rec(root_cache,
3649 BUG_ON(IS_ERR(ref_root));
3650 if (ref_root->found_ref > 0)
3653 backref->reachable = 0;
3655 if (rec->found_ref == 0)
3661 cache = search_cache_extent(root_cache, 0);
3665 rec = container_of(cache, struct root_record, cache);
3666 cache = next_cache_extent(cache);
3668 if (rec->found_ref == 0 &&
3669 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3670 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3671 ret = check_orphan_item(root->fs_info->tree_root,
3677 * If we don't have a root item then we likely just have
3678 * a dir item in a snapshot for this root but no actual
3679 * ref key or anything so it's meaningless.
3681 if (!rec->found_root_item)
3684 fprintf(stderr, "fs tree %llu not referenced\n",
3685 (unsigned long long)rec->objectid);
3689 if (rec->found_ref > 0 && !rec->found_root_item)
3691 list_for_each_entry(backref, &rec->backrefs, list) {
3692 if (!backref->found_dir_item)
3693 backref->errors |= REF_ERR_NO_DIR_ITEM;
3694 if (!backref->found_dir_index)
3695 backref->errors |= REF_ERR_NO_DIR_INDEX;
3696 if (!backref->found_back_ref)
3697 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3698 if (!backref->found_forward_ref)
3699 backref->errors |= REF_ERR_NO_ROOT_REF;
3700 if (backref->reachable && backref->errors)
3707 fprintf(stderr, "fs tree %llu refs %u %s\n",
3708 (unsigned long long)rec->objectid, rec->found_ref,
3709 rec->found_root_item ? "" : "not found");
3711 list_for_each_entry(backref, &rec->backrefs, list) {
3712 if (!backref->reachable)
3714 if (!backref->errors && rec->found_root_item)
3716 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3717 " index %llu namelen %u name %s errors %x\n",
3718 (unsigned long long)backref->ref_root,
3719 (unsigned long long)backref->dir,
3720 (unsigned long long)backref->index,
3721 backref->namelen, backref->name,
3723 print_ref_error(backref->errors);
3726 return errors > 0 ? 1 : 0;
3729 static int process_root_ref(struct extent_buffer *eb, int slot,
3730 struct btrfs_key *key,
3731 struct cache_tree *root_cache)
3737 struct btrfs_root_ref *ref;
3738 char namebuf[BTRFS_NAME_LEN];
3741 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3743 dirid = btrfs_root_ref_dirid(eb, ref);
3744 index = btrfs_root_ref_sequence(eb, ref);
3745 name_len = btrfs_root_ref_name_len(eb, ref);
3747 if (name_len <= BTRFS_NAME_LEN) {
3751 len = BTRFS_NAME_LEN;
3752 error = REF_ERR_NAME_TOO_LONG;
3754 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3756 if (key->type == BTRFS_ROOT_REF_KEY) {
3757 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3758 index, namebuf, len, key->type, error);
3760 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3761 index, namebuf, len, key->type, error);
3766 static void free_corrupt_block(struct cache_extent *cache)
3768 struct btrfs_corrupt_block *corrupt;
3770 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3774 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3777 * Repair the btree of the given root.
3779 * The fix is to remove the node key in corrupt_blocks cache_tree.
3780 * and rebalance the tree.
3781 * After the fix, the btree should be writeable.
3783 static int repair_btree(struct btrfs_root *root,
3784 struct cache_tree *corrupt_blocks)
3786 struct btrfs_trans_handle *trans;
3787 struct btrfs_path path;
3788 struct btrfs_corrupt_block *corrupt;
3789 struct cache_extent *cache;
3790 struct btrfs_key key;
3795 if (cache_tree_empty(corrupt_blocks))
3798 trans = btrfs_start_transaction(root, 1);
3799 if (IS_ERR(trans)) {
3800 ret = PTR_ERR(trans);
3801 fprintf(stderr, "Error starting transaction: %s\n",
3805 btrfs_init_path(&path);
3806 cache = first_cache_extent(corrupt_blocks);
3808 corrupt = container_of(cache, struct btrfs_corrupt_block,
3810 level = corrupt->level;
3811 path.lowest_level = level;
3812 key.objectid = corrupt->key.objectid;
3813 key.type = corrupt->key.type;
3814 key.offset = corrupt->key.offset;
3817 * Here we don't want to do any tree balance, since it may
3818 * cause a balance with corrupted brother leaf/node,
3819 * so ins_len set to 0 here.
3820 * Balance will be done after all corrupt node/leaf is deleted.
3822 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
3825 offset = btrfs_node_blockptr(path.nodes[level],
3828 /* Remove the ptr */
3829 ret = btrfs_del_ptr(trans, root, &path, level,
3834 * Remove the corresponding extent
3835 * return value is not concerned.
3837 btrfs_release_path(&path);
3838 ret = btrfs_free_extent(trans, root, offset, root->nodesize,
3839 0, root->root_key.objectid,
3841 cache = next_cache_extent(cache);
3844 /* Balance the btree using btrfs_search_slot() */
3845 cache = first_cache_extent(corrupt_blocks);
3847 corrupt = container_of(cache, struct btrfs_corrupt_block,
3849 memcpy(&key, &corrupt->key, sizeof(key));
3850 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
3853 /* return will always >0 since it won't find the item */
3855 btrfs_release_path(&path);
3856 cache = next_cache_extent(cache);
3859 btrfs_commit_transaction(trans, root);
3860 btrfs_release_path(&path);
3864 static int check_fs_root(struct btrfs_root *root,
3865 struct cache_tree *root_cache,
3866 struct walk_control *wc)
3872 struct btrfs_path path;
3873 struct shared_node root_node;
3874 struct root_record *rec;
3875 struct btrfs_root_item *root_item = &root->root_item;
3876 struct cache_tree corrupt_blocks;
3877 struct orphan_data_extent *orphan;
3878 struct orphan_data_extent *tmp;
3879 enum btrfs_tree_block_status status;
3880 struct node_refs nrefs;
3883 * Reuse the corrupt_block cache tree to record corrupted tree block
3885 * Unlike the usage in extent tree check, here we do it in a per
3886 * fs/subvol tree base.
3888 cache_tree_init(&corrupt_blocks);
3889 root->fs_info->corrupt_blocks = &corrupt_blocks;
3891 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3892 rec = get_root_rec(root_cache, root->root_key.objectid);
3893 BUG_ON(IS_ERR(rec));
3894 if (btrfs_root_refs(root_item) > 0)
3895 rec->found_root_item = 1;
3898 btrfs_init_path(&path);
3899 memset(&root_node, 0, sizeof(root_node));
3900 cache_tree_init(&root_node.root_cache);
3901 cache_tree_init(&root_node.inode_cache);
3902 memset(&nrefs, 0, sizeof(nrefs));
3904 /* Move the orphan extent record to corresponding inode_record */
3905 list_for_each_entry_safe(orphan, tmp,
3906 &root->orphan_data_extents, list) {
3907 struct inode_record *inode;
3909 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3911 BUG_ON(IS_ERR(inode));
3912 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3913 list_move(&orphan->list, &inode->orphan_extents);
3916 level = btrfs_header_level(root->node);
3917 memset(wc->nodes, 0, sizeof(wc->nodes));
3918 wc->nodes[level] = &root_node;
3919 wc->active_node = level;
3920 wc->root_level = level;
3922 /* We may not have checked the root block, lets do that now */
3923 if (btrfs_is_leaf(root->node))
3924 status = btrfs_check_leaf(root, NULL, root->node);
3926 status = btrfs_check_node(root, NULL, root->node);
3927 if (status != BTRFS_TREE_BLOCK_CLEAN)
3930 if (btrfs_root_refs(root_item) > 0 ||
3931 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3932 path.nodes[level] = root->node;
3933 extent_buffer_get(root->node);
3934 path.slots[level] = 0;
3936 struct btrfs_key key;
3937 struct btrfs_disk_key found_key;
3939 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3940 level = root_item->drop_level;
3941 path.lowest_level = level;
3942 if (level > btrfs_header_level(root->node) ||
3943 level >= BTRFS_MAX_LEVEL) {
3944 error("ignoring invalid drop level: %u", level);
3947 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3950 btrfs_node_key(path.nodes[level], &found_key,
3952 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3953 sizeof(found_key)));
3957 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
3963 wret = walk_up_tree(root, &path, wc, &level);
3970 btrfs_release_path(&path);
3972 if (!cache_tree_empty(&corrupt_blocks)) {
3973 struct cache_extent *cache;
3974 struct btrfs_corrupt_block *corrupt;
3976 printf("The following tree block(s) is corrupted in tree %llu:\n",
3977 root->root_key.objectid);
3978 cache = first_cache_extent(&corrupt_blocks);
3980 corrupt = container_of(cache,
3981 struct btrfs_corrupt_block,
3983 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
3984 cache->start, corrupt->level,
3985 corrupt->key.objectid, corrupt->key.type,
3986 corrupt->key.offset);
3987 cache = next_cache_extent(cache);
3990 printf("Try to repair the btree for root %llu\n",
3991 root->root_key.objectid);
3992 ret = repair_btree(root, &corrupt_blocks);
3994 fprintf(stderr, "Failed to repair btree: %s\n",
3997 printf("Btree for root %llu is fixed\n",
3998 root->root_key.objectid);
4002 err = merge_root_recs(root, &root_node.root_cache, root_cache);
4006 if (root_node.current) {
4007 root_node.current->checked = 1;
4008 maybe_free_inode_rec(&root_node.inode_cache,
4012 err = check_inode_recs(root, &root_node.inode_cache);
4016 free_corrupt_blocks_tree(&corrupt_blocks);
4017 root->fs_info->corrupt_blocks = NULL;
4018 free_orphan_data_extents(&root->orphan_data_extents);
4022 static int fs_root_objectid(u64 objectid)
4024 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4025 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4027 return is_fstree(objectid);
4030 static int check_fs_roots(struct btrfs_root *root,
4031 struct cache_tree *root_cache)
4033 struct btrfs_path path;
4034 struct btrfs_key key;
4035 struct walk_control wc;
4036 struct extent_buffer *leaf, *tree_node;
4037 struct btrfs_root *tmp_root;
4038 struct btrfs_root *tree_root = root->fs_info->tree_root;
4042 if (ctx.progress_enabled) {
4043 ctx.tp = TASK_FS_ROOTS;
4044 task_start(ctx.info);
4048 * Just in case we made any changes to the extent tree that weren't
4049 * reflected into the free space cache yet.
4052 reset_cached_block_groups(root->fs_info);
4053 memset(&wc, 0, sizeof(wc));
4054 cache_tree_init(&wc.shared);
4055 btrfs_init_path(&path);
4060 key.type = BTRFS_ROOT_ITEM_KEY;
4061 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4066 tree_node = tree_root->node;
4068 if (tree_node != tree_root->node) {
4069 free_root_recs_tree(root_cache);
4070 btrfs_release_path(&path);
4073 leaf = path.nodes[0];
4074 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4075 ret = btrfs_next_leaf(tree_root, &path);
4081 leaf = path.nodes[0];
4083 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4084 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4085 fs_root_objectid(key.objectid)) {
4086 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4087 tmp_root = btrfs_read_fs_root_no_cache(
4088 root->fs_info, &key);
4090 key.offset = (u64)-1;
4091 tmp_root = btrfs_read_fs_root(
4092 root->fs_info, &key);
4094 if (IS_ERR(tmp_root)) {
4098 ret = check_fs_root(tmp_root, root_cache, &wc);
4099 if (ret == -EAGAIN) {
4100 free_root_recs_tree(root_cache);
4101 btrfs_release_path(&path);
4106 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4107 btrfs_free_fs_root(tmp_root);
4108 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4109 key.type == BTRFS_ROOT_BACKREF_KEY) {
4110 process_root_ref(leaf, path.slots[0], &key,
4117 btrfs_release_path(&path);
4119 free_extent_cache_tree(&wc.shared);
4120 if (!cache_tree_empty(&wc.shared))
4121 fprintf(stderr, "warning line %d\n", __LINE__);
4123 task_stop(ctx.info);
4129 * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4130 * INODE_REF/INODE_EXTREF match.
4132 * @root: the root of the fs/file tree
4133 * @ref_key: the key of the INODE_REF/INODE_EXTREF
4134 * @key: the key of the DIR_ITEM/DIR_INDEX
4135 * @index: the index in the INODE_REF/INODE_EXTREF, be used to
4136 * distinguish root_dir between normal dir/file
4137 * @name: the name in the INODE_REF/INODE_EXTREF
4138 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4139 * @mode: the st_mode of INODE_ITEM
4141 * Return 0 if no error occurred.
4142 * Return ROOT_DIR_ERROR if found DIR_ITEM/DIR_INDEX for root_dir.
4143 * Return DIR_ITEM_MISSING if couldn't find DIR_ITEM/DIR_INDEX for normal
4145 * Return DIR_ITEM_MISMATCH if INODE_REF/INODE_EXTREF and DIR_ITEM/DIR_INDEX
4146 * not match for normal dir/file.
4148 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *ref_key,
4149 struct btrfs_key *key, u64 index, char *name,
4150 u32 namelen, u32 mode)
4152 struct btrfs_path path;
4153 struct extent_buffer *node;
4154 struct btrfs_dir_item *di;
4155 struct btrfs_key location;
4156 char namebuf[BTRFS_NAME_LEN] = {0};
4166 btrfs_init_path(&path);
4167 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4169 ret = DIR_ITEM_MISSING;
4173 /* Process root dir and goto out*/
4176 ret = ROOT_DIR_ERROR;
4178 "root %llu INODE %s[%llu %llu] ROOT_DIR shouldn't have %s",
4180 ref_key->type == BTRFS_INODE_REF_KEY ?
4182 ref_key->objectid, ref_key->offset,
4183 key->type == BTRFS_DIR_ITEM_KEY ?
4184 "DIR_ITEM" : "DIR_INDEX");
4192 /* Process normal file/dir */
4194 ret = DIR_ITEM_MISSING;
4196 "root %llu INODE %s[%llu %llu] doesn't have related %s[%llu %llu] namelen %u filename %s filetype %d",
4198 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4199 ref_key->objectid, ref_key->offset,
4200 key->type == BTRFS_DIR_ITEM_KEY ?
4201 "DIR_ITEM" : "DIR_INDEX",
4202 key->objectid, key->offset, namelen, name,
4203 imode_to_type(mode));
4207 /* Check whether inode_id/filetype/name match */
4208 node = path.nodes[0];
4209 slot = path.slots[0];
4210 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4211 total = btrfs_item_size_nr(node, slot);
4212 while (cur < total) {
4213 ret = DIR_ITEM_MISMATCH;
4214 name_len = btrfs_dir_name_len(node, di);
4215 data_len = btrfs_dir_data_len(node, di);
4217 btrfs_dir_item_key_to_cpu(node, di, &location);
4218 if (location.objectid != ref_key->objectid ||
4219 location.type != BTRFS_INODE_ITEM_KEY ||
4220 location.offset != 0)
4223 filetype = btrfs_dir_type(node, di);
4224 if (imode_to_type(mode) != filetype)
4227 if (name_len <= BTRFS_NAME_LEN) {
4230 len = BTRFS_NAME_LEN;
4231 warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4233 key->type == BTRFS_DIR_ITEM_KEY ?
4234 "DIR_ITEM" : "DIR_INDEX",
4235 key->objectid, key->offset, name_len);
4237 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4238 if (len != namelen || strncmp(namebuf, name, len))
4244 len = sizeof(*di) + name_len + data_len;
4245 di = (struct btrfs_dir_item *)((char *)di + len);
4248 if (ret == DIR_ITEM_MISMATCH)
4250 "root %llu INODE %s[%llu %llu] and %s[%llu %llu] mismatch namelen %u filename %s filetype %d",
4252 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4253 ref_key->objectid, ref_key->offset,
4254 key->type == BTRFS_DIR_ITEM_KEY ?
4255 "DIR_ITEM" : "DIR_INDEX",
4256 key->objectid, key->offset, namelen, name,
4257 imode_to_type(mode));
4259 btrfs_release_path(&path);
4264 * Traverse the given INODE_REF and call find_dir_item() to find related
4265 * DIR_ITEM/DIR_INDEX.
4267 * @root: the root of the fs/file tree
4268 * @ref_key: the key of the INODE_REF
4269 * @refs: the count of INODE_REF
4270 * @mode: the st_mode of INODE_ITEM
4272 * Return 0 if no error occurred.
4274 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4275 struct extent_buffer *node, int slot, u64 *refs,
4278 struct btrfs_key key;
4279 struct btrfs_inode_ref *ref;
4280 char namebuf[BTRFS_NAME_LEN] = {0};
4288 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4289 total = btrfs_item_size_nr(node, slot);
4292 /* Update inode ref count */
4295 index = btrfs_inode_ref_index(node, ref);
4296 name_len = btrfs_inode_ref_name_len(node, ref);
4297 if (name_len <= BTRFS_NAME_LEN) {
4300 len = BTRFS_NAME_LEN;
4301 warning("root %llu INODE_REF[%llu %llu] name too long",
4302 root->objectid, ref_key->objectid, ref_key->offset);
4305 read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
4307 /* Check root dir ref name */
4308 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4309 error("root %llu INODE_REF[%llu %llu] ROOT_DIR name shouldn't be %s",
4310 root->objectid, ref_key->objectid, ref_key->offset,
4312 err |= ROOT_DIR_ERROR;
4315 /* Find related DIR_INDEX */
4316 key.objectid = ref_key->offset;
4317 key.type = BTRFS_DIR_INDEX_KEY;
4319 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4322 /* Find related dir_item */
4323 key.objectid = ref_key->offset;
4324 key.type = BTRFS_DIR_ITEM_KEY;
4325 key.offset = btrfs_name_hash(namebuf, len);
4326 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4329 len = sizeof(*ref) + name_len;
4330 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4339 * Traverse the given INODE_EXTREF and call find_dir_item() to find related
4340 * DIR_ITEM/DIR_INDEX.
4342 * @root: the root of the fs/file tree
4343 * @ref_key: the key of the INODE_EXTREF
4344 * @refs: the count of INODE_EXTREF
4345 * @mode: the st_mode of INODE_ITEM
4347 * Return 0 if no error occurred.
4349 static int check_inode_extref(struct btrfs_root *root,
4350 struct btrfs_key *ref_key,
4351 struct extent_buffer *node, int slot, u64 *refs,
4354 struct btrfs_key key;
4355 struct btrfs_inode_extref *extref;
4356 char namebuf[BTRFS_NAME_LEN] = {0};
4366 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4367 total = btrfs_item_size_nr(node, slot);
4370 /* update inode ref count */
4372 name_len = btrfs_inode_extref_name_len(node, extref);
4373 index = btrfs_inode_extref_index(node, extref);
4374 parent = btrfs_inode_extref_parent(node, extref);
4375 if (name_len <= BTRFS_NAME_LEN) {
4378 len = BTRFS_NAME_LEN;
4379 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
4380 root->objectid, ref_key->objectid, ref_key->offset);
4382 read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
4384 /* Check root dir ref name */
4385 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4386 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
4387 root->objectid, ref_key->objectid, ref_key->offset,
4389 err |= ROOT_DIR_ERROR;
4392 /* find related dir_index */
4393 key.objectid = parent;
4394 key.type = BTRFS_DIR_INDEX_KEY;
4396 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4399 /* find related dir_item */
4400 key.objectid = parent;
4401 key.type = BTRFS_DIR_ITEM_KEY;
4402 key.offset = btrfs_name_hash(namebuf, len);
4403 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4406 len = sizeof(*extref) + name_len;
4407 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4417 * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
4418 * DIR_ITEM/DIR_INDEX match.
4420 * @root: the root of the fs/file tree
4421 * @key: the key of the INODE_REF/INODE_EXTREF
4422 * @name: the name in the INODE_REF/INODE_EXTREF
4423 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4424 * @index: the index in the INODE_REF/INODE_EXTREF, for DIR_ITEM set index
4426 * @ext_ref: the EXTENDED_IREF feature
4428 * Return 0 if no error occurred.
4429 * Return >0 for error bitmap
4431 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
4432 char *name, int namelen, u64 index,
4433 unsigned int ext_ref)
4435 struct btrfs_path path;
4436 struct btrfs_inode_ref *ref;
4437 struct btrfs_inode_extref *extref;
4438 struct extent_buffer *node;
4439 char ref_namebuf[BTRFS_NAME_LEN] = {0};
4450 btrfs_init_path(&path);
4451 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4453 ret = INODE_REF_MISSING;
4457 node = path.nodes[0];
4458 slot = path.slots[0];
4460 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4461 total = btrfs_item_size_nr(node, slot);
4463 /* Iterate all entry of INODE_REF */
4464 while (cur < total) {
4465 ret = INODE_REF_MISSING;
4467 ref_namelen = btrfs_inode_ref_name_len(node, ref);
4468 ref_index = btrfs_inode_ref_index(node, ref);
4469 if (index != (u64)-1 && index != ref_index)
4472 if (ref_namelen <= BTRFS_NAME_LEN) {
4475 len = BTRFS_NAME_LEN;
4476 warning("root %llu INODE %s[%llu %llu] name too long",
4478 key->type == BTRFS_INODE_REF_KEY ?
4480 key->objectid, key->offset);
4482 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
4485 if (len != namelen || strncmp(ref_namebuf, name, len))
4491 len = sizeof(*ref) + ref_namelen;
4492 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4497 /* Skip if not support EXTENDED_IREF feature */
4501 btrfs_release_path(&path);
4502 btrfs_init_path(&path);
4504 dir_id = key->offset;
4505 key->type = BTRFS_INODE_EXTREF_KEY;
4506 key->offset = btrfs_extref_hash(dir_id, name, namelen);
4508 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4510 ret = INODE_REF_MISSING;
4514 node = path.nodes[0];
4515 slot = path.slots[0];
4517 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4519 total = btrfs_item_size_nr(node, slot);
4521 /* Iterate all entry of INODE_EXTREF */
4522 while (cur < total) {
4523 ret = INODE_REF_MISSING;
4525 ref_namelen = btrfs_inode_extref_name_len(node, extref);
4526 ref_index = btrfs_inode_extref_index(node, extref);
4527 parent = btrfs_inode_extref_parent(node, extref);
4528 if (index != (u64)-1 && index != ref_index)
4531 if (parent != dir_id)
4534 if (ref_namelen <= BTRFS_NAME_LEN) {
4537 len = BTRFS_NAME_LEN;
4538 warning("root %llu INODE %s[%llu %llu] name too long",
4540 key->type == BTRFS_INODE_REF_KEY ?
4542 key->objectid, key->offset);
4544 read_extent_buffer(node, ref_namebuf,
4545 (unsigned long)(extref + 1), len);
4547 if (len != namelen || strncmp(ref_namebuf, name, len))
4554 len = sizeof(*extref) + ref_namelen;
4555 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4560 btrfs_release_path(&path);
4565 * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
4566 * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
4568 * @root: the root of the fs/file tree
4569 * @key: the key of the INODE_REF/INODE_EXTREF
4570 * @size: the st_size of the INODE_ITEM
4571 * @ext_ref: the EXTENDED_IREF feature
4573 * Return 0 if no error occurred.
4575 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4576 struct extent_buffer *node, int slot, u64 *size,
4577 unsigned int ext_ref)
4579 struct btrfs_dir_item *di;
4580 struct btrfs_inode_item *ii;
4581 struct btrfs_path path;
4582 struct btrfs_key location;
4583 char namebuf[BTRFS_NAME_LEN] = {0};
4596 * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
4597 * ignore index check.
4599 index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
4601 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4602 total = btrfs_item_size_nr(node, slot);
4604 while (cur < total) {
4605 data_len = btrfs_dir_data_len(node, di);
4607 error("root %llu %s[%llu %llu] data_len shouldn't be %u",
4608 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4609 "DIR_ITEM" : "DIR_INDEX",
4610 key->objectid, key->offset, data_len);
4612 name_len = btrfs_dir_name_len(node, di);
4613 if (name_len <= BTRFS_NAME_LEN) {
4616 len = BTRFS_NAME_LEN;
4617 warning("root %llu %s[%llu %llu] name too long",
4619 key->type == BTRFS_DIR_ITEM_KEY ?
4620 "DIR_ITEM" : "DIR_INDEX",
4621 key->objectid, key->offset);
4623 (*size) += name_len;
4625 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4626 filetype = btrfs_dir_type(node, di);
4628 btrfs_init_path(&path);
4629 btrfs_dir_item_key_to_cpu(node, di, &location);
4631 /* Ignore related ROOT_ITEM check */
4632 if (location.type == BTRFS_ROOT_ITEM_KEY)
4635 /* Check relative INODE_ITEM(existence/filetype) */
4636 ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
4638 err |= INODE_ITEM_MISSING;
4639 error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
4640 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4641 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4642 key->offset, location.objectid, name_len,
4647 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4648 struct btrfs_inode_item);
4649 mode = btrfs_inode_mode(path.nodes[0], ii);
4651 if (imode_to_type(mode) != filetype) {
4652 err |= INODE_ITEM_MISMATCH;
4653 error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
4654 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4655 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4656 key->offset, name_len, namebuf, filetype);
4659 /* Check relative INODE_REF/INODE_EXTREF */
4660 location.type = BTRFS_INODE_REF_KEY;
4661 location.offset = key->objectid;
4662 ret = find_inode_ref(root, &location, namebuf, len,
4665 if (ret & INODE_REF_MISSING)
4666 error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
4667 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4668 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4669 key->offset, name_len, namebuf, filetype);
4672 btrfs_release_path(&path);
4673 len = sizeof(*di) + name_len + data_len;
4674 di = (struct btrfs_dir_item *)((char *)di + len);
4677 if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
4678 error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
4679 root->objectid, key->objectid, key->offset);
4688 * Check file extent datasum/hole, update the size of the file extents,
4689 * check and update the last offset of the file extent.
4691 * @root: the root of fs/file tree.
4692 * @fkey: the key of the file extent.
4693 * @nodatasum: INODE_NODATASUM feature.
4694 * @size: the sum of all EXTENT_DATA items size for this inode.
4695 * @end: the offset of the last extent.
4697 * Return 0 if no error occurred.
4699 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
4700 struct extent_buffer *node, int slot,
4701 unsigned int nodatasum, u64 *size, u64 *end)
4703 struct btrfs_file_extent_item *fi;
4706 u64 extent_num_bytes;
4708 unsigned int extent_type;
4709 unsigned int is_hole;
4713 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4715 extent_type = btrfs_file_extent_type(node, fi);
4716 /* Skip if file extent is inline */
4717 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4718 struct btrfs_item *e = btrfs_item_nr(slot);
4719 u32 item_inline_len;
4721 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4722 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4723 if (extent_num_bytes == 0 ||
4724 extent_num_bytes != item_inline_len)
4725 err |= FILE_EXTENT_ERROR;
4726 *size += extent_num_bytes;
4730 /* Check extent type */
4731 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4732 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4733 err |= FILE_EXTENT_ERROR;
4734 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4735 root->objectid, fkey->objectid, fkey->offset);
4739 /* Check REG_EXTENT/PREALLOC_EXTENT */
4740 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4741 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4742 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4743 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4745 /* Check EXTENT_DATA datasum */
4746 ret = count_csum_range(root, disk_bytenr, disk_num_bytes, &found);
4747 if (found > 0 && nodatasum) {
4748 err |= ODD_CSUM_ITEM;
4749 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4750 root->objectid, fkey->objectid, fkey->offset);
4751 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4753 (ret < 0 || found == 0 || found < disk_num_bytes)) {
4754 err |= CSUM_ITEM_MISSING;
4755 error("root %llu EXTENT_DATA[%llu %llu] datasum missing",
4756 root->objectid, fkey->objectid, fkey->offset);
4757 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && found > 0) {
4758 err |= ODD_CSUM_ITEM;
4759 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have datasum",
4760 root->objectid, fkey->objectid, fkey->offset);
4763 /* Check EXTENT_DATA hole */
4764 if (no_holes && is_hole) {
4765 err |= FILE_EXTENT_ERROR;
4766 error("root %llu EXTENT_DATA[%llu %llu] shouldn't be hole",
4767 root->objectid, fkey->objectid, fkey->offset);
4768 } else if (!no_holes && *end != fkey->offset) {
4769 err |= FILE_EXTENT_ERROR;
4770 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4771 root->objectid, fkey->objectid, fkey->offset);
4774 *end += extent_num_bytes;
4776 *size += extent_num_bytes;
4782 * Check INODE_ITEM and related ITEMs (the same inode number)
4783 * 1. check link count
4784 * 2. check inode ref/extref
4785 * 3. check dir item/index
4787 * @ext_ref: the EXTENDED_IREF feature
4789 * Return 0 if no error occurred.
4790 * Return >0 for error or hit the traversal is done(by error bitmap)
4792 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4793 unsigned int ext_ref)
4795 struct extent_buffer *node;
4796 struct btrfs_inode_item *ii;
4797 struct btrfs_key key;
4806 u64 extent_size = 0;
4808 unsigned int nodatasum;
4813 node = path->nodes[0];
4814 slot = path->slots[0];
4816 btrfs_item_key_to_cpu(node, &key, slot);
4817 inode_id = key.objectid;
4819 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4820 ret = btrfs_next_item(root, path);
4826 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4827 isize = btrfs_inode_size(node, ii);
4828 nbytes = btrfs_inode_nbytes(node, ii);
4829 mode = btrfs_inode_mode(node, ii);
4830 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4831 nlink = btrfs_inode_nlink(node, ii);
4832 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4835 ret = btrfs_next_item(root, path);
4837 /* out will fill 'err' rusing current statistics */
4839 } else if (ret > 0) {
4844 node = path->nodes[0];
4845 slot = path->slots[0];
4846 btrfs_item_key_to_cpu(node, &key, slot);
4847 if (key.objectid != inode_id)
4851 case BTRFS_INODE_REF_KEY:
4852 ret = check_inode_ref(root, &key, node, slot, &refs,
4856 case BTRFS_INODE_EXTREF_KEY:
4857 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4858 warning("root %llu EXTREF[%llu %llu] isn't supported",
4859 root->objectid, key.objectid,
4861 ret = check_inode_extref(root, &key, node, slot, &refs,
4865 case BTRFS_DIR_ITEM_KEY:
4866 case BTRFS_DIR_INDEX_KEY:
4868 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4869 root->objectid, inode_id,
4870 imode_to_type(mode), key.objectid,
4873 ret = check_dir_item(root, &key, node, slot, &size,
4877 case BTRFS_EXTENT_DATA_KEY:
4879 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4880 root->objectid, inode_id, key.objectid,
4883 ret = check_file_extent(root, &key, node, slot,
4884 nodatasum, &extent_size,
4888 case BTRFS_XATTR_ITEM_KEY:
4891 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4892 key.objectid, key.type, key.offset);
4897 /* verify INODE_ITEM nlink/isize/nbytes */
4900 err |= LINK_COUNT_ERROR;
4901 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4902 root->objectid, inode_id, nlink);
4906 * Just a warning, as dir inode nbytes is just an
4907 * instructive value.
4909 if (!IS_ALIGNED(nbytes, root->nodesize)) {
4910 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
4911 root->objectid, inode_id, root->nodesize);
4914 if (isize != size) {
4916 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
4917 root->objectid, inode_id, isize, size);
4920 if (nlink != refs) {
4921 err |= LINK_COUNT_ERROR;
4922 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
4923 root->objectid, inode_id, nlink, refs);
4924 } else if (!nlink) {
4928 if (!nbytes && !no_holes && extent_end < isize) {
4929 err |= NBYTES_ERROR;
4930 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
4931 root->objectid, inode_id, isize);
4934 if (nbytes != extent_size) {
4935 err |= NBYTES_ERROR;
4936 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
4937 root->objectid, inode_id, nbytes, extent_size);
4944 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4946 struct btrfs_path path;
4947 struct btrfs_key key;
4951 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4952 key.type = BTRFS_INODE_ITEM_KEY;
4955 /* For root being dropped, we don't need to check first inode */
4956 if (btrfs_root_refs(&root->root_item) == 0 &&
4957 btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
4961 btrfs_init_path(&path);
4963 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4968 err |= INODE_ITEM_MISSING;
4971 err |= check_inode_item(root, &path, ext_ref);
4976 btrfs_release_path(&path);
4981 * Iterate all item on the tree and call check_inode_item() to check.
4983 * @root: the root of the tree to be checked.
4984 * @ext_ref: the EXTENDED_IREF feature
4986 * Return 0 if no error found.
4987 * Return <0 for error.
4989 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
4991 struct btrfs_path path;
4992 struct node_refs nrefs;
4993 struct btrfs_root_item *root_item = &root->root_item;
4998 * We need to manually check the first inode item(256)
4999 * As the following traversal function will only start from
5000 * the first inode item in the leaf, if inode item(256) is missing
5001 * we will just skip it forever.
5003 ret = check_fs_first_inode(root, ext_ref);
5007 memset(&nrefs, 0, sizeof(nrefs));
5008 level = btrfs_header_level(root->node);
5009 btrfs_init_path(&path);
5011 if (btrfs_root_refs(root_item) > 0 ||
5012 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5013 path.nodes[level] = root->node;
5014 path.slots[level] = 0;
5015 extent_buffer_get(root->node);
5017 struct btrfs_key key;
5019 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5020 level = root_item->drop_level;
5021 path.lowest_level = level;
5022 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5029 wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5035 wret = walk_up_tree_v2(root, &path, &level);
5043 btrfs_release_path(&path);
5048 * Find the relative ref for root_ref and root_backref.
5050 * @root: the root of the root tree.
5051 * @ref_key: the key of the root ref.
5053 * Return 0 if no error occurred.
5055 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5056 struct extent_buffer *node, int slot)
5058 struct btrfs_path path;
5059 struct btrfs_key key;
5060 struct btrfs_root_ref *ref;
5061 struct btrfs_root_ref *backref;
5062 char ref_name[BTRFS_NAME_LEN] = {0};
5063 char backref_name[BTRFS_NAME_LEN] = {0};
5069 u32 backref_namelen;
5074 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5075 ref_dirid = btrfs_root_ref_dirid(node, ref);
5076 ref_seq = btrfs_root_ref_sequence(node, ref);
5077 ref_namelen = btrfs_root_ref_name_len(node, ref);
5079 if (ref_namelen <= BTRFS_NAME_LEN) {
5082 len = BTRFS_NAME_LEN;
5083 warning("%s[%llu %llu] ref_name too long",
5084 ref_key->type == BTRFS_ROOT_REF_KEY ?
5085 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5088 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5090 /* Find relative root_ref */
5091 key.objectid = ref_key->offset;
5092 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5093 key.offset = ref_key->objectid;
5095 btrfs_init_path(&path);
5096 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5098 err |= ROOT_REF_MISSING;
5099 error("%s[%llu %llu] couldn't find relative ref",
5100 ref_key->type == BTRFS_ROOT_REF_KEY ?
5101 "ROOT_REF" : "ROOT_BACKREF",
5102 ref_key->objectid, ref_key->offset);
5106 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5107 struct btrfs_root_ref);
5108 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5109 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5110 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5112 if (backref_namelen <= BTRFS_NAME_LEN) {
5113 len = backref_namelen;
5115 len = BTRFS_NAME_LEN;
5116 warning("%s[%llu %llu] ref_name too long",
5117 key.type == BTRFS_ROOT_REF_KEY ?
5118 "ROOT_REF" : "ROOT_BACKREF",
5119 key.objectid, key.offset);
5121 read_extent_buffer(path.nodes[0], backref_name,
5122 (unsigned long)(backref + 1), len);
5124 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5125 ref_namelen != backref_namelen ||
5126 strncmp(ref_name, backref_name, len)) {
5127 err |= ROOT_REF_MISMATCH;
5128 error("%s[%llu %llu] mismatch relative ref",
5129 ref_key->type == BTRFS_ROOT_REF_KEY ?
5130 "ROOT_REF" : "ROOT_BACKREF",
5131 ref_key->objectid, ref_key->offset);
5134 btrfs_release_path(&path);
5139 * Check all fs/file tree in low_memory mode.
5141 * 1. for fs tree root item, call check_fs_root_v2()
5142 * 2. for fs tree root ref/backref, call check_root_ref()
5144 * Return 0 if no error occurred.
5146 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5148 struct btrfs_root *tree_root = fs_info->tree_root;
5149 struct btrfs_root *cur_root = NULL;
5150 struct btrfs_path path;
5151 struct btrfs_key key;
5152 struct extent_buffer *node;
5153 unsigned int ext_ref;
5158 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5160 btrfs_init_path(&path);
5161 key.objectid = BTRFS_FS_TREE_OBJECTID;
5163 key.type = BTRFS_ROOT_ITEM_KEY;
5165 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5169 } else if (ret > 0) {
5175 node = path.nodes[0];
5176 slot = path.slots[0];
5177 btrfs_item_key_to_cpu(node, &key, slot);
5178 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5180 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5181 fs_root_objectid(key.objectid)) {
5182 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5183 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5186 key.offset = (u64)-1;
5187 cur_root = btrfs_read_fs_root(fs_info, &key);
5190 if (IS_ERR(cur_root)) {
5191 error("Fail to read fs/subvol tree: %lld",
5197 ret = check_fs_root_v2(cur_root, ext_ref);
5200 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5201 btrfs_free_fs_root(cur_root);
5202 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5203 key.type == BTRFS_ROOT_BACKREF_KEY) {
5204 ret = check_root_ref(tree_root, &key, node, slot);
5208 ret = btrfs_next_item(tree_root, &path);
5218 btrfs_release_path(&path);
5222 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5224 struct list_head *cur = rec->backrefs.next;
5225 struct extent_backref *back;
5226 struct tree_backref *tback;
5227 struct data_backref *dback;
5231 while(cur != &rec->backrefs) {
5232 back = to_extent_backref(cur);
5234 if (!back->found_extent_tree) {
5238 if (back->is_data) {
5239 dback = to_data_backref(back);
5240 fprintf(stderr, "Backref %llu %s %llu"
5241 " owner %llu offset %llu num_refs %lu"
5242 " not found in extent tree\n",
5243 (unsigned long long)rec->start,
5244 back->full_backref ?
5246 back->full_backref ?
5247 (unsigned long long)dback->parent:
5248 (unsigned long long)dback->root,
5249 (unsigned long long)dback->owner,
5250 (unsigned long long)dback->offset,
5251 (unsigned long)dback->num_refs);
5253 tback = to_tree_backref(back);
5254 fprintf(stderr, "Backref %llu parent %llu"
5255 " root %llu not found in extent tree\n",
5256 (unsigned long long)rec->start,
5257 (unsigned long long)tback->parent,
5258 (unsigned long long)tback->root);
5261 if (!back->is_data && !back->found_ref) {
5265 tback = to_tree_backref(back);
5266 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5267 (unsigned long long)rec->start,
5268 back->full_backref ? "parent" : "root",
5269 back->full_backref ?
5270 (unsigned long long)tback->parent :
5271 (unsigned long long)tback->root, back);
5273 if (back->is_data) {
5274 dback = to_data_backref(back);
5275 if (dback->found_ref != dback->num_refs) {
5279 fprintf(stderr, "Incorrect local backref count"
5280 " on %llu %s %llu owner %llu"
5281 " offset %llu found %u wanted %u back %p\n",
5282 (unsigned long long)rec->start,
5283 back->full_backref ?
5285 back->full_backref ?
5286 (unsigned long long)dback->parent:
5287 (unsigned long long)dback->root,
5288 (unsigned long long)dback->owner,
5289 (unsigned long long)dback->offset,
5290 dback->found_ref, dback->num_refs, back);
5292 if (dback->disk_bytenr != rec->start) {
5296 fprintf(stderr, "Backref disk bytenr does not"
5297 " match extent record, bytenr=%llu, "
5298 "ref bytenr=%llu\n",
5299 (unsigned long long)rec->start,
5300 (unsigned long long)dback->disk_bytenr);
5303 if (dback->bytes != rec->nr) {
5307 fprintf(stderr, "Backref bytes do not match "
5308 "extent backref, bytenr=%llu, ref "
5309 "bytes=%llu, backref bytes=%llu\n",
5310 (unsigned long long)rec->start,
5311 (unsigned long long)rec->nr,
5312 (unsigned long long)dback->bytes);
5315 if (!back->is_data) {
5318 dback = to_data_backref(back);
5319 found += dback->found_ref;
5322 if (found != rec->refs) {
5326 fprintf(stderr, "Incorrect global backref count "
5327 "on %llu found %llu wanted %llu\n",
5328 (unsigned long long)rec->start,
5329 (unsigned long long)found,
5330 (unsigned long long)rec->refs);
5336 static int free_all_extent_backrefs(struct extent_record *rec)
5338 struct extent_backref *back;
5339 struct list_head *cur;
5340 while (!list_empty(&rec->backrefs)) {
5341 cur = rec->backrefs.next;
5342 back = to_extent_backref(cur);
5349 static void free_extent_record_cache(struct btrfs_fs_info *fs_info,
5350 struct cache_tree *extent_cache)
5352 struct cache_extent *cache;
5353 struct extent_record *rec;
5356 cache = first_cache_extent(extent_cache);
5359 rec = container_of(cache, struct extent_record, cache);
5360 remove_cache_extent(extent_cache, cache);
5361 free_all_extent_backrefs(rec);
5366 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5367 struct extent_record *rec)
5369 if (rec->content_checked && rec->owner_ref_checked &&
5370 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5371 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5372 !rec->bad_full_backref && !rec->crossing_stripes &&
5373 !rec->wrong_chunk_type) {
5374 remove_cache_extent(extent_cache, &rec->cache);
5375 free_all_extent_backrefs(rec);
5376 list_del_init(&rec->list);
5382 static int check_owner_ref(struct btrfs_root *root,
5383 struct extent_record *rec,
5384 struct extent_buffer *buf)
5386 struct extent_backref *node;
5387 struct tree_backref *back;
5388 struct btrfs_root *ref_root;
5389 struct btrfs_key key;
5390 struct btrfs_path path;
5391 struct extent_buffer *parent;
5396 list_for_each_entry(node, &rec->backrefs, list) {
5399 if (!node->found_ref)
5401 if (node->full_backref)
5403 back = to_tree_backref(node);
5404 if (btrfs_header_owner(buf) == back->root)
5407 BUG_ON(rec->is_root);
5409 /* try to find the block by search corresponding fs tree */
5410 key.objectid = btrfs_header_owner(buf);
5411 key.type = BTRFS_ROOT_ITEM_KEY;
5412 key.offset = (u64)-1;
5414 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5415 if (IS_ERR(ref_root))
5418 level = btrfs_header_level(buf);
5420 btrfs_item_key_to_cpu(buf, &key, 0);
5422 btrfs_node_key_to_cpu(buf, &key, 0);
5424 btrfs_init_path(&path);
5425 path.lowest_level = level + 1;
5426 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5430 parent = path.nodes[level + 1];
5431 if (parent && buf->start == btrfs_node_blockptr(parent,
5432 path.slots[level + 1]))
5435 btrfs_release_path(&path);
5436 return found ? 0 : 1;
5439 static int is_extent_tree_record(struct extent_record *rec)
5441 struct list_head *cur = rec->backrefs.next;
5442 struct extent_backref *node;
5443 struct tree_backref *back;
5446 while(cur != &rec->backrefs) {
5447 node = to_extent_backref(cur);
5451 back = to_tree_backref(node);
5452 if (node->full_backref)
5454 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5461 static int record_bad_block_io(struct btrfs_fs_info *info,
5462 struct cache_tree *extent_cache,
5465 struct extent_record *rec;
5466 struct cache_extent *cache;
5467 struct btrfs_key key;
5469 cache = lookup_cache_extent(extent_cache, start, len);
5473 rec = container_of(cache, struct extent_record, cache);
5474 if (!is_extent_tree_record(rec))
5477 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5478 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5481 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5482 struct extent_buffer *buf, int slot)
5484 if (btrfs_header_level(buf)) {
5485 struct btrfs_key_ptr ptr1, ptr2;
5487 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5488 sizeof(struct btrfs_key_ptr));
5489 read_extent_buffer(buf, &ptr2,
5490 btrfs_node_key_ptr_offset(slot + 1),
5491 sizeof(struct btrfs_key_ptr));
5492 write_extent_buffer(buf, &ptr1,
5493 btrfs_node_key_ptr_offset(slot + 1),
5494 sizeof(struct btrfs_key_ptr));
5495 write_extent_buffer(buf, &ptr2,
5496 btrfs_node_key_ptr_offset(slot),
5497 sizeof(struct btrfs_key_ptr));
5499 struct btrfs_disk_key key;
5500 btrfs_node_key(buf, &key, 0);
5501 btrfs_fixup_low_keys(root, path, &key,
5502 btrfs_header_level(buf) + 1);
5505 struct btrfs_item *item1, *item2;
5506 struct btrfs_key k1, k2;
5507 char *item1_data, *item2_data;
5508 u32 item1_offset, item2_offset, item1_size, item2_size;
5510 item1 = btrfs_item_nr(slot);
5511 item2 = btrfs_item_nr(slot + 1);
5512 btrfs_item_key_to_cpu(buf, &k1, slot);
5513 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5514 item1_offset = btrfs_item_offset(buf, item1);
5515 item2_offset = btrfs_item_offset(buf, item2);
5516 item1_size = btrfs_item_size(buf, item1);
5517 item2_size = btrfs_item_size(buf, item2);
5519 item1_data = malloc(item1_size);
5522 item2_data = malloc(item2_size);
5528 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5529 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5531 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5532 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5536 btrfs_set_item_offset(buf, item1, item2_offset);
5537 btrfs_set_item_offset(buf, item2, item1_offset);
5538 btrfs_set_item_size(buf, item1, item2_size);
5539 btrfs_set_item_size(buf, item2, item1_size);
5541 path->slots[0] = slot;
5542 btrfs_set_item_key_unsafe(root, path, &k2);
5543 path->slots[0] = slot + 1;
5544 btrfs_set_item_key_unsafe(root, path, &k1);
5549 static int fix_key_order(struct btrfs_trans_handle *trans,
5550 struct btrfs_root *root,
5551 struct btrfs_path *path)
5553 struct extent_buffer *buf;
5554 struct btrfs_key k1, k2;
5556 int level = path->lowest_level;
5559 buf = path->nodes[level];
5560 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5562 btrfs_node_key_to_cpu(buf, &k1, i);
5563 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5565 btrfs_item_key_to_cpu(buf, &k1, i);
5566 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5568 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5570 ret = swap_values(root, path, buf, i);
5573 btrfs_mark_buffer_dirty(buf);
5579 static int delete_bogus_item(struct btrfs_trans_handle *trans,
5580 struct btrfs_root *root,
5581 struct btrfs_path *path,
5582 struct extent_buffer *buf, int slot)
5584 struct btrfs_key key;
5585 int nritems = btrfs_header_nritems(buf);
5587 btrfs_item_key_to_cpu(buf, &key, slot);
5589 /* These are all the keys we can deal with missing. */
5590 if (key.type != BTRFS_DIR_INDEX_KEY &&
5591 key.type != BTRFS_EXTENT_ITEM_KEY &&
5592 key.type != BTRFS_METADATA_ITEM_KEY &&
5593 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5594 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5597 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5598 (unsigned long long)key.objectid, key.type,
5599 (unsigned long long)key.offset, slot, buf->start);
5600 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5601 btrfs_item_nr_offset(slot + 1),
5602 sizeof(struct btrfs_item) *
5603 (nritems - slot - 1));
5604 btrfs_set_header_nritems(buf, nritems - 1);
5606 struct btrfs_disk_key disk_key;
5608 btrfs_item_key(buf, &disk_key, 0);
5609 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5611 btrfs_mark_buffer_dirty(buf);
5615 static int fix_item_offset(struct btrfs_trans_handle *trans,
5616 struct btrfs_root *root,
5617 struct btrfs_path *path)
5619 struct extent_buffer *buf;
5623 /* We should only get this for leaves */
5624 BUG_ON(path->lowest_level);
5625 buf = path->nodes[0];
5627 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5628 unsigned int shift = 0, offset;
5630 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5631 BTRFS_LEAF_DATA_SIZE(root)) {
5632 if (btrfs_item_end_nr(buf, i) >
5633 BTRFS_LEAF_DATA_SIZE(root)) {
5634 ret = delete_bogus_item(trans, root, path,
5638 fprintf(stderr, "item is off the end of the "
5639 "leaf, can't fix\n");
5643 shift = BTRFS_LEAF_DATA_SIZE(root) -
5644 btrfs_item_end_nr(buf, i);
5645 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5646 btrfs_item_offset_nr(buf, i - 1)) {
5647 if (btrfs_item_end_nr(buf, i) >
5648 btrfs_item_offset_nr(buf, i - 1)) {
5649 ret = delete_bogus_item(trans, root, path,
5653 fprintf(stderr, "items overlap, can't fix\n");
5657 shift = btrfs_item_offset_nr(buf, i - 1) -
5658 btrfs_item_end_nr(buf, i);
5663 printf("Shifting item nr %d by %u bytes in block %llu\n",
5664 i, shift, (unsigned long long)buf->start);
5665 offset = btrfs_item_offset_nr(buf, i);
5666 memmove_extent_buffer(buf,
5667 btrfs_leaf_data(buf) + offset + shift,
5668 btrfs_leaf_data(buf) + offset,
5669 btrfs_item_size_nr(buf, i));
5670 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5672 btrfs_mark_buffer_dirty(buf);
5676 * We may have moved things, in which case we want to exit so we don't
5677 * write those changes out. Once we have proper abort functionality in
5678 * progs this can be changed to something nicer.
5685 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5686 * then just return -EIO.
5688 static int try_to_fix_bad_block(struct btrfs_root *root,
5689 struct extent_buffer *buf,
5690 enum btrfs_tree_block_status status)
5692 struct btrfs_trans_handle *trans;
5693 struct ulist *roots;
5694 struct ulist_node *node;
5695 struct btrfs_root *search_root;
5696 struct btrfs_path path;
5697 struct ulist_iterator iter;
5698 struct btrfs_key root_key, key;
5701 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5702 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5705 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5709 btrfs_init_path(&path);
5710 ULIST_ITER_INIT(&iter);
5711 while ((node = ulist_next(roots, &iter))) {
5712 root_key.objectid = node->val;
5713 root_key.type = BTRFS_ROOT_ITEM_KEY;
5714 root_key.offset = (u64)-1;
5716 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5723 trans = btrfs_start_transaction(search_root, 0);
5724 if (IS_ERR(trans)) {
5725 ret = PTR_ERR(trans);
5729 path.lowest_level = btrfs_header_level(buf);
5730 path.skip_check_block = 1;
5731 if (path.lowest_level)
5732 btrfs_node_key_to_cpu(buf, &key, 0);
5734 btrfs_item_key_to_cpu(buf, &key, 0);
5735 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5738 btrfs_commit_transaction(trans, search_root);
5741 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5742 ret = fix_key_order(trans, search_root, &path);
5743 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5744 ret = fix_item_offset(trans, search_root, &path);
5746 btrfs_commit_transaction(trans, search_root);
5749 btrfs_release_path(&path);
5750 btrfs_commit_transaction(trans, search_root);
5753 btrfs_release_path(&path);
5757 static int check_block(struct btrfs_root *root,
5758 struct cache_tree *extent_cache,
5759 struct extent_buffer *buf, u64 flags)
5761 struct extent_record *rec;
5762 struct cache_extent *cache;
5763 struct btrfs_key key;
5764 enum btrfs_tree_block_status status;
5768 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5771 rec = container_of(cache, struct extent_record, cache);
5772 rec->generation = btrfs_header_generation(buf);
5774 level = btrfs_header_level(buf);
5775 if (btrfs_header_nritems(buf) > 0) {
5778 btrfs_item_key_to_cpu(buf, &key, 0);
5780 btrfs_node_key_to_cpu(buf, &key, 0);
5782 rec->info_objectid = key.objectid;
5784 rec->info_level = level;
5786 if (btrfs_is_leaf(buf))
5787 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5789 status = btrfs_check_node(root, &rec->parent_key, buf);
5791 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5793 status = try_to_fix_bad_block(root, buf, status);
5794 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5796 fprintf(stderr, "bad block %llu\n",
5797 (unsigned long long)buf->start);
5800 * Signal to callers we need to start the scan over
5801 * again since we'll have cowed blocks.
5806 rec->content_checked = 1;
5807 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5808 rec->owner_ref_checked = 1;
5810 ret = check_owner_ref(root, rec, buf);
5812 rec->owner_ref_checked = 1;
5816 maybe_free_extent_rec(extent_cache, rec);
5820 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5821 u64 parent, u64 root)
5823 struct list_head *cur = rec->backrefs.next;
5824 struct extent_backref *node;
5825 struct tree_backref *back;
5827 while(cur != &rec->backrefs) {
5828 node = to_extent_backref(cur);
5832 back = to_tree_backref(node);
5834 if (!node->full_backref)
5836 if (parent == back->parent)
5839 if (node->full_backref)
5841 if (back->root == root)
5848 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5849 u64 parent, u64 root)
5851 struct tree_backref *ref = malloc(sizeof(*ref));
5855 memset(&ref->node, 0, sizeof(ref->node));
5857 ref->parent = parent;
5858 ref->node.full_backref = 1;
5861 ref->node.full_backref = 0;
5863 list_add_tail(&ref->node.list, &rec->backrefs);
5868 static struct data_backref *find_data_backref(struct extent_record *rec,
5869 u64 parent, u64 root,
5870 u64 owner, u64 offset,
5872 u64 disk_bytenr, u64 bytes)
5874 struct list_head *cur = rec->backrefs.next;
5875 struct extent_backref *node;
5876 struct data_backref *back;
5878 while(cur != &rec->backrefs) {
5879 node = to_extent_backref(cur);
5883 back = to_data_backref(node);
5885 if (!node->full_backref)
5887 if (parent == back->parent)
5890 if (node->full_backref)
5892 if (back->root == root && back->owner == owner &&
5893 back->offset == offset) {
5894 if (found_ref && node->found_ref &&
5895 (back->bytes != bytes ||
5896 back->disk_bytenr != disk_bytenr))
5905 static struct data_backref *alloc_data_backref(struct extent_record *rec,
5906 u64 parent, u64 root,
5907 u64 owner, u64 offset,
5910 struct data_backref *ref = malloc(sizeof(*ref));
5914 memset(&ref->node, 0, sizeof(ref->node));
5915 ref->node.is_data = 1;
5918 ref->parent = parent;
5921 ref->node.full_backref = 1;
5925 ref->offset = offset;
5926 ref->node.full_backref = 0;
5928 ref->bytes = max_size;
5931 list_add_tail(&ref->node.list, &rec->backrefs);
5932 if (max_size > rec->max_size)
5933 rec->max_size = max_size;
5937 /* Check if the type of extent matches with its chunk */
5938 static void check_extent_type(struct extent_record *rec)
5940 struct btrfs_block_group_cache *bg_cache;
5942 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
5946 /* data extent, check chunk directly*/
5947 if (!rec->metadata) {
5948 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
5949 rec->wrong_chunk_type = 1;
5953 /* metadata extent, check the obvious case first */
5954 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
5955 BTRFS_BLOCK_GROUP_METADATA))) {
5956 rec->wrong_chunk_type = 1;
5961 * Check SYSTEM extent, as it's also marked as metadata, we can only
5962 * make sure it's a SYSTEM extent by its backref
5964 if (!list_empty(&rec->backrefs)) {
5965 struct extent_backref *node;
5966 struct tree_backref *tback;
5969 node = to_extent_backref(rec->backrefs.next);
5970 if (node->is_data) {
5971 /* tree block shouldn't have data backref */
5972 rec->wrong_chunk_type = 1;
5975 tback = container_of(node, struct tree_backref, node);
5977 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
5978 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
5980 bg_type = BTRFS_BLOCK_GROUP_METADATA;
5981 if (!(bg_cache->flags & bg_type))
5982 rec->wrong_chunk_type = 1;
5987 * Allocate a new extent record, fill default values from @tmpl and insert int
5988 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
5989 * the cache, otherwise it fails.
5991 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
5992 struct extent_record *tmpl)
5994 struct extent_record *rec;
5997 rec = malloc(sizeof(*rec));
6000 rec->start = tmpl->start;
6001 rec->max_size = tmpl->max_size;
6002 rec->nr = max(tmpl->nr, tmpl->max_size);
6003 rec->found_rec = tmpl->found_rec;
6004 rec->content_checked = tmpl->content_checked;
6005 rec->owner_ref_checked = tmpl->owner_ref_checked;
6006 rec->num_duplicates = 0;
6007 rec->metadata = tmpl->metadata;
6008 rec->flag_block_full_backref = FLAG_UNSET;
6009 rec->bad_full_backref = 0;
6010 rec->crossing_stripes = 0;
6011 rec->wrong_chunk_type = 0;
6012 rec->is_root = tmpl->is_root;
6013 rec->refs = tmpl->refs;
6014 rec->extent_item_refs = tmpl->extent_item_refs;
6015 rec->parent_generation = tmpl->parent_generation;
6016 INIT_LIST_HEAD(&rec->backrefs);
6017 INIT_LIST_HEAD(&rec->dups);
6018 INIT_LIST_HEAD(&rec->list);
6019 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6020 rec->cache.start = tmpl->start;
6021 rec->cache.size = tmpl->nr;
6022 ret = insert_cache_extent(extent_cache, &rec->cache);
6027 bytes_used += rec->nr;
6030 rec->crossing_stripes = check_crossing_stripes(global_info,
6031 rec->start, global_info->tree_root->nodesize);
6032 check_extent_type(rec);
6037 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6039 * - refs - if found, increase refs
6040 * - is_root - if found, set
6041 * - content_checked - if found, set
6042 * - owner_ref_checked - if found, set
6044 * If not found, create a new one, initialize and insert.
6046 static int add_extent_rec(struct cache_tree *extent_cache,
6047 struct extent_record *tmpl)
6049 struct extent_record *rec;
6050 struct cache_extent *cache;
6054 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6056 rec = container_of(cache, struct extent_record, cache);
6060 rec->nr = max(tmpl->nr, tmpl->max_size);
6063 * We need to make sure to reset nr to whatever the extent
6064 * record says was the real size, this way we can compare it to
6067 if (tmpl->found_rec) {
6068 if (tmpl->start != rec->start || rec->found_rec) {
6069 struct extent_record *tmp;
6072 if (list_empty(&rec->list))
6073 list_add_tail(&rec->list,
6074 &duplicate_extents);
6077 * We have to do this song and dance in case we
6078 * find an extent record that falls inside of
6079 * our current extent record but does not have
6080 * the same objectid.
6082 tmp = malloc(sizeof(*tmp));
6085 tmp->start = tmpl->start;
6086 tmp->max_size = tmpl->max_size;
6089 tmp->metadata = tmpl->metadata;
6090 tmp->extent_item_refs = tmpl->extent_item_refs;
6091 INIT_LIST_HEAD(&tmp->list);
6092 list_add_tail(&tmp->list, &rec->dups);
6093 rec->num_duplicates++;
6100 if (tmpl->extent_item_refs && !dup) {
6101 if (rec->extent_item_refs) {
6102 fprintf(stderr, "block %llu rec "
6103 "extent_item_refs %llu, passed %llu\n",
6104 (unsigned long long)tmpl->start,
6105 (unsigned long long)
6106 rec->extent_item_refs,
6107 (unsigned long long)tmpl->extent_item_refs);
6109 rec->extent_item_refs = tmpl->extent_item_refs;
6113 if (tmpl->content_checked)
6114 rec->content_checked = 1;
6115 if (tmpl->owner_ref_checked)
6116 rec->owner_ref_checked = 1;
6117 memcpy(&rec->parent_key, &tmpl->parent_key,
6118 sizeof(tmpl->parent_key));
6119 if (tmpl->parent_generation)
6120 rec->parent_generation = tmpl->parent_generation;
6121 if (rec->max_size < tmpl->max_size)
6122 rec->max_size = tmpl->max_size;
6125 * A metadata extent can't cross stripe_len boundary, otherwise
6126 * kernel scrub won't be able to handle it.
6127 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6131 rec->crossing_stripes = check_crossing_stripes(
6132 global_info, rec->start,
6133 global_info->tree_root->nodesize);
6134 check_extent_type(rec);
6135 maybe_free_extent_rec(extent_cache, rec);
6139 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6144 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6145 u64 parent, u64 root, int found_ref)
6147 struct extent_record *rec;
6148 struct tree_backref *back;
6149 struct cache_extent *cache;
6152 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6154 struct extent_record tmpl;
6156 memset(&tmpl, 0, sizeof(tmpl));
6157 tmpl.start = bytenr;
6161 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6165 /* really a bug in cache_extent implement now */
6166 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6171 rec = container_of(cache, struct extent_record, cache);
6172 if (rec->start != bytenr) {
6174 * Several cause, from unaligned bytenr to over lapping extents
6179 back = find_tree_backref(rec, parent, root);
6181 back = alloc_tree_backref(rec, parent, root);
6187 if (back->node.found_ref) {
6188 fprintf(stderr, "Extent back ref already exists "
6189 "for %llu parent %llu root %llu \n",
6190 (unsigned long long)bytenr,
6191 (unsigned long long)parent,
6192 (unsigned long long)root);
6194 back->node.found_ref = 1;
6196 if (back->node.found_extent_tree) {
6197 fprintf(stderr, "Extent back ref already exists "
6198 "for %llu parent %llu root %llu \n",
6199 (unsigned long long)bytenr,
6200 (unsigned long long)parent,
6201 (unsigned long long)root);
6203 back->node.found_extent_tree = 1;
6205 check_extent_type(rec);
6206 maybe_free_extent_rec(extent_cache, rec);
6210 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6211 u64 parent, u64 root, u64 owner, u64 offset,
6212 u32 num_refs, int found_ref, u64 max_size)
6214 struct extent_record *rec;
6215 struct data_backref *back;
6216 struct cache_extent *cache;
6219 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6221 struct extent_record tmpl;
6223 memset(&tmpl, 0, sizeof(tmpl));
6224 tmpl.start = bytenr;
6226 tmpl.max_size = max_size;
6228 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6232 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6237 rec = container_of(cache, struct extent_record, cache);
6238 if (rec->max_size < max_size)
6239 rec->max_size = max_size;
6242 * If found_ref is set then max_size is the real size and must match the
6243 * existing refs. So if we have already found a ref then we need to
6244 * make sure that this ref matches the existing one, otherwise we need
6245 * to add a new backref so we can notice that the backrefs don't match
6246 * and we need to figure out who is telling the truth. This is to
6247 * account for that awful fsync bug I introduced where we'd end up with
6248 * a btrfs_file_extent_item that would have its length include multiple
6249 * prealloc extents or point inside of a prealloc extent.
6251 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6254 back = alloc_data_backref(rec, parent, root, owner, offset,
6260 BUG_ON(num_refs != 1);
6261 if (back->node.found_ref)
6262 BUG_ON(back->bytes != max_size);
6263 back->node.found_ref = 1;
6264 back->found_ref += 1;
6265 back->bytes = max_size;
6266 back->disk_bytenr = bytenr;
6268 rec->content_checked = 1;
6269 rec->owner_ref_checked = 1;
6271 if (back->node.found_extent_tree) {
6272 fprintf(stderr, "Extent back ref already exists "
6273 "for %llu parent %llu root %llu "
6274 "owner %llu offset %llu num_refs %lu\n",
6275 (unsigned long long)bytenr,
6276 (unsigned long long)parent,
6277 (unsigned long long)root,
6278 (unsigned long long)owner,
6279 (unsigned long long)offset,
6280 (unsigned long)num_refs);
6282 back->num_refs = num_refs;
6283 back->node.found_extent_tree = 1;
6285 maybe_free_extent_rec(extent_cache, rec);
6289 static int add_pending(struct cache_tree *pending,
6290 struct cache_tree *seen, u64 bytenr, u32 size)
6293 ret = add_cache_extent(seen, bytenr, size);
6296 add_cache_extent(pending, bytenr, size);
6300 static int pick_next_pending(struct cache_tree *pending,
6301 struct cache_tree *reada,
6302 struct cache_tree *nodes,
6303 u64 last, struct block_info *bits, int bits_nr,
6306 unsigned long node_start = last;
6307 struct cache_extent *cache;
6310 cache = search_cache_extent(reada, 0);
6312 bits[0].start = cache->start;
6313 bits[0].size = cache->size;
6318 if (node_start > 32768)
6319 node_start -= 32768;
6321 cache = search_cache_extent(nodes, node_start);
6323 cache = search_cache_extent(nodes, 0);
6326 cache = search_cache_extent(pending, 0);
6331 bits[ret].start = cache->start;
6332 bits[ret].size = cache->size;
6333 cache = next_cache_extent(cache);
6335 } while (cache && ret < bits_nr);
6341 bits[ret].start = cache->start;
6342 bits[ret].size = cache->size;
6343 cache = next_cache_extent(cache);
6345 } while (cache && ret < bits_nr);
6347 if (bits_nr - ret > 8) {
6348 u64 lookup = bits[0].start + bits[0].size;
6349 struct cache_extent *next;
6350 next = search_cache_extent(pending, lookup);
6352 if (next->start - lookup > 32768)
6354 bits[ret].start = next->start;
6355 bits[ret].size = next->size;
6356 lookup = next->start + next->size;
6360 next = next_cache_extent(next);
6368 static void free_chunk_record(struct cache_extent *cache)
6370 struct chunk_record *rec;
6372 rec = container_of(cache, struct chunk_record, cache);
6373 list_del_init(&rec->list);
6374 list_del_init(&rec->dextents);
6378 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6380 cache_tree_free_extents(chunk_cache, free_chunk_record);
6383 static void free_device_record(struct rb_node *node)
6385 struct device_record *rec;
6387 rec = container_of(node, struct device_record, node);
6391 FREE_RB_BASED_TREE(device_cache, free_device_record);
6393 int insert_block_group_record(struct block_group_tree *tree,
6394 struct block_group_record *bg_rec)
6398 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6402 list_add_tail(&bg_rec->list, &tree->block_groups);
6406 static void free_block_group_record(struct cache_extent *cache)
6408 struct block_group_record *rec;
6410 rec = container_of(cache, struct block_group_record, cache);
6411 list_del_init(&rec->list);
6415 void free_block_group_tree(struct block_group_tree *tree)
6417 cache_tree_free_extents(&tree->tree, free_block_group_record);
6420 int insert_device_extent_record(struct device_extent_tree *tree,
6421 struct device_extent_record *de_rec)
6426 * Device extent is a bit different from the other extents, because
6427 * the extents which belong to the different devices may have the
6428 * same start and size, so we need use the special extent cache
6429 * search/insert functions.
6431 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6435 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6436 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6440 static void free_device_extent_record(struct cache_extent *cache)
6442 struct device_extent_record *rec;
6444 rec = container_of(cache, struct device_extent_record, cache);
6445 if (!list_empty(&rec->chunk_list))
6446 list_del_init(&rec->chunk_list);
6447 if (!list_empty(&rec->device_list))
6448 list_del_init(&rec->device_list);
6452 void free_device_extent_tree(struct device_extent_tree *tree)
6454 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6457 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6458 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6459 struct extent_buffer *leaf, int slot)
6461 struct btrfs_extent_ref_v0 *ref0;
6462 struct btrfs_key key;
6465 btrfs_item_key_to_cpu(leaf, &key, slot);
6466 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6467 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6468 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6471 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6472 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6478 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6479 struct btrfs_key *key,
6482 struct btrfs_chunk *ptr;
6483 struct chunk_record *rec;
6486 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6487 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6489 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6491 fprintf(stderr, "memory allocation failed\n");
6495 INIT_LIST_HEAD(&rec->list);
6496 INIT_LIST_HEAD(&rec->dextents);
6499 rec->cache.start = key->offset;
6500 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6502 rec->generation = btrfs_header_generation(leaf);
6504 rec->objectid = key->objectid;
6505 rec->type = key->type;
6506 rec->offset = key->offset;
6508 rec->length = rec->cache.size;
6509 rec->owner = btrfs_chunk_owner(leaf, ptr);
6510 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6511 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6512 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6513 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6514 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6515 rec->num_stripes = num_stripes;
6516 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6518 for (i = 0; i < rec->num_stripes; ++i) {
6519 rec->stripes[i].devid =
6520 btrfs_stripe_devid_nr(leaf, ptr, i);
6521 rec->stripes[i].offset =
6522 btrfs_stripe_offset_nr(leaf, ptr, i);
6523 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6524 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6531 static int process_chunk_item(struct cache_tree *chunk_cache,
6532 struct btrfs_key *key, struct extent_buffer *eb,
6535 struct chunk_record *rec;
6536 struct btrfs_chunk *chunk;
6539 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6541 * Do extra check for this chunk item,
6543 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6544 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6545 * and owner<->key_type check.
6547 ret = btrfs_check_chunk_valid(global_info->tree_root, eb, chunk, slot,
6550 error("chunk(%llu, %llu) is not valid, ignore it",
6551 key->offset, btrfs_chunk_length(eb, chunk));
6554 rec = btrfs_new_chunk_record(eb, key, slot);
6555 ret = insert_cache_extent(chunk_cache, &rec->cache);
6557 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6558 rec->offset, rec->length);
6565 static int process_device_item(struct rb_root *dev_cache,
6566 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6568 struct btrfs_dev_item *ptr;
6569 struct device_record *rec;
6572 ptr = btrfs_item_ptr(eb,
6573 slot, struct btrfs_dev_item);
6575 rec = malloc(sizeof(*rec));
6577 fprintf(stderr, "memory allocation failed\n");
6581 rec->devid = key->offset;
6582 rec->generation = btrfs_header_generation(eb);
6584 rec->objectid = key->objectid;
6585 rec->type = key->type;
6586 rec->offset = key->offset;
6588 rec->devid = btrfs_device_id(eb, ptr);
6589 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6590 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6592 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6594 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6601 struct block_group_record *
6602 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6605 struct btrfs_block_group_item *ptr;
6606 struct block_group_record *rec;
6608 rec = calloc(1, sizeof(*rec));
6610 fprintf(stderr, "memory allocation failed\n");
6614 rec->cache.start = key->objectid;
6615 rec->cache.size = key->offset;
6617 rec->generation = btrfs_header_generation(leaf);
6619 rec->objectid = key->objectid;
6620 rec->type = key->type;
6621 rec->offset = key->offset;
6623 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6624 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6626 INIT_LIST_HEAD(&rec->list);
6631 static int process_block_group_item(struct block_group_tree *block_group_cache,
6632 struct btrfs_key *key,
6633 struct extent_buffer *eb, int slot)
6635 struct block_group_record *rec;
6638 rec = btrfs_new_block_group_record(eb, key, slot);
6639 ret = insert_block_group_record(block_group_cache, rec);
6641 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6642 rec->objectid, rec->offset);
6649 struct device_extent_record *
6650 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6651 struct btrfs_key *key, int slot)
6653 struct device_extent_record *rec;
6654 struct btrfs_dev_extent *ptr;
6656 rec = calloc(1, sizeof(*rec));
6658 fprintf(stderr, "memory allocation failed\n");
6662 rec->cache.objectid = key->objectid;
6663 rec->cache.start = key->offset;
6665 rec->generation = btrfs_header_generation(leaf);
6667 rec->objectid = key->objectid;
6668 rec->type = key->type;
6669 rec->offset = key->offset;
6671 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6672 rec->chunk_objecteid =
6673 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6675 btrfs_dev_extent_chunk_offset(leaf, ptr);
6676 rec->length = btrfs_dev_extent_length(leaf, ptr);
6677 rec->cache.size = rec->length;
6679 INIT_LIST_HEAD(&rec->chunk_list);
6680 INIT_LIST_HEAD(&rec->device_list);
6686 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6687 struct btrfs_key *key, struct extent_buffer *eb,
6690 struct device_extent_record *rec;
6693 rec = btrfs_new_device_extent_record(eb, key, slot);
6694 ret = insert_device_extent_record(dev_extent_cache, rec);
6697 "Device extent[%llu, %llu, %llu] existed.\n",
6698 rec->objectid, rec->offset, rec->length);
6705 static int process_extent_item(struct btrfs_root *root,
6706 struct cache_tree *extent_cache,
6707 struct extent_buffer *eb, int slot)
6709 struct btrfs_extent_item *ei;
6710 struct btrfs_extent_inline_ref *iref;
6711 struct btrfs_extent_data_ref *dref;
6712 struct btrfs_shared_data_ref *sref;
6713 struct btrfs_key key;
6714 struct extent_record tmpl;
6719 u32 item_size = btrfs_item_size_nr(eb, slot);
6725 btrfs_item_key_to_cpu(eb, &key, slot);
6727 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6729 num_bytes = root->nodesize;
6731 num_bytes = key.offset;
6734 if (!IS_ALIGNED(key.objectid, root->sectorsize)) {
6735 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6736 key.objectid, root->sectorsize);
6739 if (item_size < sizeof(*ei)) {
6740 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6741 struct btrfs_extent_item_v0 *ei0;
6742 BUG_ON(item_size != sizeof(*ei0));
6743 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6744 refs = btrfs_extent_refs_v0(eb, ei0);
6748 memset(&tmpl, 0, sizeof(tmpl));
6749 tmpl.start = key.objectid;
6750 tmpl.nr = num_bytes;
6751 tmpl.extent_item_refs = refs;
6752 tmpl.metadata = metadata;
6754 tmpl.max_size = num_bytes;
6756 return add_extent_rec(extent_cache, &tmpl);
6759 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6760 refs = btrfs_extent_refs(eb, ei);
6761 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6765 if (metadata && num_bytes != root->nodesize) {
6766 error("ignore invalid metadata extent, length %llu does not equal to %u",
6767 num_bytes, root->nodesize);
6770 if (!metadata && !IS_ALIGNED(num_bytes, root->sectorsize)) {
6771 error("ignore invalid data extent, length %llu is not aligned to %u",
6772 num_bytes, root->sectorsize);
6776 memset(&tmpl, 0, sizeof(tmpl));
6777 tmpl.start = key.objectid;
6778 tmpl.nr = num_bytes;
6779 tmpl.extent_item_refs = refs;
6780 tmpl.metadata = metadata;
6782 tmpl.max_size = num_bytes;
6783 add_extent_rec(extent_cache, &tmpl);
6785 ptr = (unsigned long)(ei + 1);
6786 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6787 key.type == BTRFS_EXTENT_ITEM_KEY)
6788 ptr += sizeof(struct btrfs_tree_block_info);
6790 end = (unsigned long)ei + item_size;
6792 iref = (struct btrfs_extent_inline_ref *)ptr;
6793 type = btrfs_extent_inline_ref_type(eb, iref);
6794 offset = btrfs_extent_inline_ref_offset(eb, iref);
6796 case BTRFS_TREE_BLOCK_REF_KEY:
6797 ret = add_tree_backref(extent_cache, key.objectid,
6800 error("add_tree_backref failed: %s",
6803 case BTRFS_SHARED_BLOCK_REF_KEY:
6804 ret = add_tree_backref(extent_cache, key.objectid,
6807 error("add_tree_backref failed: %s",
6810 case BTRFS_EXTENT_DATA_REF_KEY:
6811 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6812 add_data_backref(extent_cache, key.objectid, 0,
6813 btrfs_extent_data_ref_root(eb, dref),
6814 btrfs_extent_data_ref_objectid(eb,
6816 btrfs_extent_data_ref_offset(eb, dref),
6817 btrfs_extent_data_ref_count(eb, dref),
6820 case BTRFS_SHARED_DATA_REF_KEY:
6821 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6822 add_data_backref(extent_cache, key.objectid, offset,
6824 btrfs_shared_data_ref_count(eb, sref),
6828 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6829 key.objectid, key.type, num_bytes);
6832 ptr += btrfs_extent_inline_ref_size(type);
6839 static int check_cache_range(struct btrfs_root *root,
6840 struct btrfs_block_group_cache *cache,
6841 u64 offset, u64 bytes)
6843 struct btrfs_free_space *entry;
6849 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6850 bytenr = btrfs_sb_offset(i);
6851 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
6852 cache->key.objectid, bytenr, 0,
6853 &logical, &nr, &stripe_len);
6858 if (logical[nr] + stripe_len <= offset)
6860 if (offset + bytes <= logical[nr])
6862 if (logical[nr] == offset) {
6863 if (stripe_len >= bytes) {
6867 bytes -= stripe_len;
6868 offset += stripe_len;
6869 } else if (logical[nr] < offset) {
6870 if (logical[nr] + stripe_len >=
6875 bytes = (offset + bytes) -
6876 (logical[nr] + stripe_len);
6877 offset = logical[nr] + stripe_len;
6880 * Could be tricky, the super may land in the
6881 * middle of the area we're checking. First
6882 * check the easiest case, it's at the end.
6884 if (logical[nr] + stripe_len >=
6886 bytes = logical[nr] - offset;
6890 /* Check the left side */
6891 ret = check_cache_range(root, cache,
6893 logical[nr] - offset);
6899 /* Now we continue with the right side */
6900 bytes = (offset + bytes) -
6901 (logical[nr] + stripe_len);
6902 offset = logical[nr] + stripe_len;
6909 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
6911 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
6912 offset, offset+bytes);
6916 if (entry->offset != offset) {
6917 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
6922 if (entry->bytes != bytes) {
6923 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
6924 bytes, entry->bytes, offset);
6928 unlink_free_space(cache->free_space_ctl, entry);
6933 static int verify_space_cache(struct btrfs_root *root,
6934 struct btrfs_block_group_cache *cache)
6936 struct btrfs_path path;
6937 struct extent_buffer *leaf;
6938 struct btrfs_key key;
6942 root = root->fs_info->extent_root;
6944 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
6946 btrfs_init_path(&path);
6947 key.objectid = last;
6949 key.type = BTRFS_EXTENT_ITEM_KEY;
6950 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6955 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
6956 ret = btrfs_next_leaf(root, &path);
6964 leaf = path.nodes[0];
6965 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
6966 if (key.objectid >= cache->key.offset + cache->key.objectid)
6968 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
6969 key.type != BTRFS_METADATA_ITEM_KEY) {
6974 if (last == key.objectid) {
6975 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6976 last = key.objectid + key.offset;
6978 last = key.objectid + root->nodesize;
6983 ret = check_cache_range(root, cache, last,
6984 key.objectid - last);
6987 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6988 last = key.objectid + key.offset;
6990 last = key.objectid + root->nodesize;
6994 if (last < cache->key.objectid + cache->key.offset)
6995 ret = check_cache_range(root, cache, last,
6996 cache->key.objectid +
6997 cache->key.offset - last);
7000 btrfs_release_path(&path);
7003 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
7004 fprintf(stderr, "There are still entries left in the space "
7012 static int check_space_cache(struct btrfs_root *root)
7014 struct btrfs_block_group_cache *cache;
7015 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7019 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7020 btrfs_super_generation(root->fs_info->super_copy) !=
7021 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7022 printf("cache and super generation don't match, space cache "
7023 "will be invalidated\n");
7027 if (ctx.progress_enabled) {
7028 ctx.tp = TASK_FREE_SPACE;
7029 task_start(ctx.info);
7033 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7037 start = cache->key.objectid + cache->key.offset;
7038 if (!cache->free_space_ctl) {
7039 if (btrfs_init_free_space_ctl(cache,
7040 root->sectorsize)) {
7045 btrfs_remove_free_space_cache(cache);
7048 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7049 ret = exclude_super_stripes(root, cache);
7051 fprintf(stderr, "could not exclude super stripes: %s\n",
7056 ret = load_free_space_tree(root->fs_info, cache);
7057 free_excluded_extents(root, cache);
7059 fprintf(stderr, "could not load free space tree: %s\n",
7066 ret = load_free_space_cache(root->fs_info, cache);
7071 ret = verify_space_cache(root, cache);
7073 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7074 cache->key.objectid);
7079 task_stop(ctx.info);
7081 return error ? -EINVAL : 0;
7084 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7085 u64 num_bytes, unsigned long leaf_offset,
7086 struct extent_buffer *eb) {
7089 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7091 unsigned long csum_offset;
7095 u64 data_checked = 0;
7101 if (num_bytes % root->sectorsize)
7104 data = malloc(num_bytes);
7108 while (offset < num_bytes) {
7111 read_len = num_bytes - offset;
7112 /* read as much space once a time */
7113 ret = read_extent_data(root, data + offset,
7114 bytenr + offset, &read_len, mirror);
7118 /* verify every 4k data's checksum */
7119 while (data_checked < read_len) {
7121 tmp = offset + data_checked;
7123 csum = btrfs_csum_data(NULL, (char *)data + tmp,
7124 csum, root->sectorsize);
7125 btrfs_csum_final(csum, (u8 *)&csum);
7127 csum_offset = leaf_offset +
7128 tmp / root->sectorsize * csum_size;
7129 read_extent_buffer(eb, (char *)&csum_expected,
7130 csum_offset, csum_size);
7131 /* try another mirror */
7132 if (csum != csum_expected) {
7133 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7134 mirror, bytenr + tmp,
7135 csum, csum_expected);
7136 num_copies = btrfs_num_copies(
7137 &root->fs_info->mapping_tree,
7139 if (mirror < num_copies - 1) {
7144 data_checked += root->sectorsize;
7153 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7156 struct btrfs_path path;
7157 struct extent_buffer *leaf;
7158 struct btrfs_key key;
7161 btrfs_init_path(&path);
7162 key.objectid = bytenr;
7163 key.type = BTRFS_EXTENT_ITEM_KEY;
7164 key.offset = (u64)-1;
7167 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7170 fprintf(stderr, "Error looking up extent record %d\n", ret);
7171 btrfs_release_path(&path);
7174 if (path.slots[0] > 0) {
7177 ret = btrfs_prev_leaf(root, &path);
7180 } else if (ret > 0) {
7187 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7190 * Block group items come before extent items if they have the same
7191 * bytenr, so walk back one more just in case. Dear future traveller,
7192 * first congrats on mastering time travel. Now if it's not too much
7193 * trouble could you go back to 2006 and tell Chris to make the
7194 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7195 * EXTENT_ITEM_KEY please?
7197 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7198 if (path.slots[0] > 0) {
7201 ret = btrfs_prev_leaf(root, &path);
7204 } else if (ret > 0) {
7209 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7213 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7214 ret = btrfs_next_leaf(root, &path);
7216 fprintf(stderr, "Error going to next leaf "
7218 btrfs_release_path(&path);
7224 leaf = path.nodes[0];
7225 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7226 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7230 if (key.objectid + key.offset < bytenr) {
7234 if (key.objectid > bytenr + num_bytes)
7237 if (key.objectid == bytenr) {
7238 if (key.offset >= num_bytes) {
7242 num_bytes -= key.offset;
7243 bytenr += key.offset;
7244 } else if (key.objectid < bytenr) {
7245 if (key.objectid + key.offset >= bytenr + num_bytes) {
7249 num_bytes = (bytenr + num_bytes) -
7250 (key.objectid + key.offset);
7251 bytenr = key.objectid + key.offset;
7253 if (key.objectid + key.offset < bytenr + num_bytes) {
7254 u64 new_start = key.objectid + key.offset;
7255 u64 new_bytes = bytenr + num_bytes - new_start;
7258 * Weird case, the extent is in the middle of
7259 * our range, we'll have to search one side
7260 * and then the other. Not sure if this happens
7261 * in real life, but no harm in coding it up
7262 * anyway just in case.
7264 btrfs_release_path(&path);
7265 ret = check_extent_exists(root, new_start,
7268 fprintf(stderr, "Right section didn't "
7272 num_bytes = key.objectid - bytenr;
7275 num_bytes = key.objectid - bytenr;
7282 if (num_bytes && !ret) {
7283 fprintf(stderr, "There are no extents for csum range "
7284 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7288 btrfs_release_path(&path);
7292 static int check_csums(struct btrfs_root *root)
7294 struct btrfs_path path;
7295 struct extent_buffer *leaf;
7296 struct btrfs_key key;
7297 u64 offset = 0, num_bytes = 0;
7298 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7302 unsigned long leaf_offset;
7304 root = root->fs_info->csum_root;
7305 if (!extent_buffer_uptodate(root->node)) {
7306 fprintf(stderr, "No valid csum tree found\n");
7310 btrfs_init_path(&path);
7311 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7312 key.type = BTRFS_EXTENT_CSUM_KEY;
7314 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7316 fprintf(stderr, "Error searching csum tree %d\n", ret);
7317 btrfs_release_path(&path);
7321 if (ret > 0 && path.slots[0])
7326 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7327 ret = btrfs_next_leaf(root, &path);
7329 fprintf(stderr, "Error going to next leaf "
7336 leaf = path.nodes[0];
7338 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7339 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7344 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7345 csum_size) * root->sectorsize;
7346 if (!check_data_csum)
7347 goto skip_csum_check;
7348 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7349 ret = check_extent_csums(root, key.offset, data_len,
7355 offset = key.offset;
7356 } else if (key.offset != offset + num_bytes) {
7357 ret = check_extent_exists(root, offset, num_bytes);
7359 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7360 "there is no extent record\n",
7361 offset, offset+num_bytes);
7364 offset = key.offset;
7367 num_bytes += data_len;
7371 btrfs_release_path(&path);
7375 static int is_dropped_key(struct btrfs_key *key,
7376 struct btrfs_key *drop_key) {
7377 if (key->objectid < drop_key->objectid)
7379 else if (key->objectid == drop_key->objectid) {
7380 if (key->type < drop_key->type)
7382 else if (key->type == drop_key->type) {
7383 if (key->offset < drop_key->offset)
7391 * Here are the rules for FULL_BACKREF.
7393 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7394 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7396 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7397 * if it happened after the relocation occurred since we'll have dropped the
7398 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7399 * have no real way to know for sure.
7401 * We process the blocks one root at a time, and we start from the lowest root
7402 * objectid and go to the highest. So we can just lookup the owner backref for
7403 * the record and if we don't find it then we know it doesn't exist and we have
7406 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7407 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7408 * be set or not and then we can check later once we've gathered all the refs.
7410 static int calc_extent_flag(struct btrfs_root *root,
7411 struct cache_tree *extent_cache,
7412 struct extent_buffer *buf,
7413 struct root_item_record *ri,
7416 struct extent_record *rec;
7417 struct cache_extent *cache;
7418 struct tree_backref *tback;
7421 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7422 /* we have added this extent before */
7426 rec = container_of(cache, struct extent_record, cache);
7429 * Except file/reloc tree, we can not have
7432 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7437 if (buf->start == ri->bytenr)
7440 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7443 owner = btrfs_header_owner(buf);
7444 if (owner == ri->objectid)
7447 tback = find_tree_backref(rec, 0, owner);
7452 if (rec->flag_block_full_backref != FLAG_UNSET &&
7453 rec->flag_block_full_backref != 0)
7454 rec->bad_full_backref = 1;
7457 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7458 if (rec->flag_block_full_backref != FLAG_UNSET &&
7459 rec->flag_block_full_backref != 1)
7460 rec->bad_full_backref = 1;
7464 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7466 fprintf(stderr, "Invalid key type(");
7467 print_key_type(stderr, 0, key_type);
7468 fprintf(stderr, ") found in root(");
7469 print_objectid(stderr, rootid, 0);
7470 fprintf(stderr, ")\n");
7474 * Check if the key is valid with its extent buffer.
7476 * This is a early check in case invalid key exists in a extent buffer
7477 * This is not comprehensive yet, but should prevent wrong key/item passed
7480 static int check_type_with_root(u64 rootid, u8 key_type)
7483 /* Only valid in chunk tree */
7484 case BTRFS_DEV_ITEM_KEY:
7485 case BTRFS_CHUNK_ITEM_KEY:
7486 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7489 /* valid in csum and log tree */
7490 case BTRFS_CSUM_TREE_OBJECTID:
7491 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7495 case BTRFS_EXTENT_ITEM_KEY:
7496 case BTRFS_METADATA_ITEM_KEY:
7497 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7498 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7501 case BTRFS_ROOT_ITEM_KEY:
7502 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7505 case BTRFS_DEV_EXTENT_KEY:
7506 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7512 report_mismatch_key_root(key_type, rootid);
7516 static int run_next_block(struct btrfs_root *root,
7517 struct block_info *bits,
7520 struct cache_tree *pending,
7521 struct cache_tree *seen,
7522 struct cache_tree *reada,
7523 struct cache_tree *nodes,
7524 struct cache_tree *extent_cache,
7525 struct cache_tree *chunk_cache,
7526 struct rb_root *dev_cache,
7527 struct block_group_tree *block_group_cache,
7528 struct device_extent_tree *dev_extent_cache,
7529 struct root_item_record *ri)
7531 struct extent_buffer *buf;
7532 struct extent_record *rec = NULL;
7543 struct btrfs_key key;
7544 struct cache_extent *cache;
7547 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7548 bits_nr, &reada_bits);
7553 for(i = 0; i < nritems; i++) {
7554 ret = add_cache_extent(reada, bits[i].start,
7559 /* fixme, get the parent transid */
7560 readahead_tree_block(root, bits[i].start,
7564 *last = bits[0].start;
7565 bytenr = bits[0].start;
7566 size = bits[0].size;
7568 cache = lookup_cache_extent(pending, bytenr, size);
7570 remove_cache_extent(pending, cache);
7573 cache = lookup_cache_extent(reada, bytenr, size);
7575 remove_cache_extent(reada, cache);
7578 cache = lookup_cache_extent(nodes, bytenr, size);
7580 remove_cache_extent(nodes, cache);
7583 cache = lookup_cache_extent(extent_cache, bytenr, size);
7585 rec = container_of(cache, struct extent_record, cache);
7586 gen = rec->parent_generation;
7589 /* fixme, get the real parent transid */
7590 buf = read_tree_block(root, bytenr, size, gen);
7591 if (!extent_buffer_uptodate(buf)) {
7592 record_bad_block_io(root->fs_info,
7593 extent_cache, bytenr, size);
7597 nritems = btrfs_header_nritems(buf);
7600 if (!init_extent_tree) {
7601 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7602 btrfs_header_level(buf), 1, NULL,
7605 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7607 fprintf(stderr, "Couldn't calc extent flags\n");
7608 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7613 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7615 fprintf(stderr, "Couldn't calc extent flags\n");
7616 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7620 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7622 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7623 ri->objectid == btrfs_header_owner(buf)) {
7625 * Ok we got to this block from it's original owner and
7626 * we have FULL_BACKREF set. Relocation can leave
7627 * converted blocks over so this is altogether possible,
7628 * however it's not possible if the generation > the
7629 * last snapshot, so check for this case.
7631 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7632 btrfs_header_generation(buf) > ri->last_snapshot) {
7633 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7634 rec->bad_full_backref = 1;
7639 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7640 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7641 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7642 rec->bad_full_backref = 1;
7646 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7647 rec->flag_block_full_backref = 1;
7651 rec->flag_block_full_backref = 0;
7653 owner = btrfs_header_owner(buf);
7656 ret = check_block(root, extent_cache, buf, flags);
7660 if (btrfs_is_leaf(buf)) {
7661 btree_space_waste += btrfs_leaf_free_space(root, buf);
7662 for (i = 0; i < nritems; i++) {
7663 struct btrfs_file_extent_item *fi;
7664 btrfs_item_key_to_cpu(buf, &key, i);
7666 * Check key type against the leaf owner.
7667 * Could filter quite a lot of early error if
7670 if (check_type_with_root(btrfs_header_owner(buf),
7672 fprintf(stderr, "ignoring invalid key\n");
7675 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7676 process_extent_item(root, extent_cache, buf,
7680 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7681 process_extent_item(root, extent_cache, buf,
7685 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7687 btrfs_item_size_nr(buf, i);
7690 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7691 process_chunk_item(chunk_cache, &key, buf, i);
7694 if (key.type == BTRFS_DEV_ITEM_KEY) {
7695 process_device_item(dev_cache, &key, buf, i);
7698 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7699 process_block_group_item(block_group_cache,
7703 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7704 process_device_extent_item(dev_extent_cache,
7709 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7710 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7711 process_extent_ref_v0(extent_cache, buf, i);
7718 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7719 ret = add_tree_backref(extent_cache,
7720 key.objectid, 0, key.offset, 0);
7722 error("add_tree_backref failed: %s",
7726 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7727 ret = add_tree_backref(extent_cache,
7728 key.objectid, key.offset, 0, 0);
7730 error("add_tree_backref failed: %s",
7734 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7735 struct btrfs_extent_data_ref *ref;
7736 ref = btrfs_item_ptr(buf, i,
7737 struct btrfs_extent_data_ref);
7738 add_data_backref(extent_cache,
7740 btrfs_extent_data_ref_root(buf, ref),
7741 btrfs_extent_data_ref_objectid(buf,
7743 btrfs_extent_data_ref_offset(buf, ref),
7744 btrfs_extent_data_ref_count(buf, ref),
7745 0, root->sectorsize);
7748 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7749 struct btrfs_shared_data_ref *ref;
7750 ref = btrfs_item_ptr(buf, i,
7751 struct btrfs_shared_data_ref);
7752 add_data_backref(extent_cache,
7753 key.objectid, key.offset, 0, 0, 0,
7754 btrfs_shared_data_ref_count(buf, ref),
7755 0, root->sectorsize);
7758 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7759 struct bad_item *bad;
7761 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7765 bad = malloc(sizeof(struct bad_item));
7768 INIT_LIST_HEAD(&bad->list);
7769 memcpy(&bad->key, &key,
7770 sizeof(struct btrfs_key));
7771 bad->root_id = owner;
7772 list_add_tail(&bad->list, &delete_items);
7775 if (key.type != BTRFS_EXTENT_DATA_KEY)
7777 fi = btrfs_item_ptr(buf, i,
7778 struct btrfs_file_extent_item);
7779 if (btrfs_file_extent_type(buf, fi) ==
7780 BTRFS_FILE_EXTENT_INLINE)
7782 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7785 data_bytes_allocated +=
7786 btrfs_file_extent_disk_num_bytes(buf, fi);
7787 if (data_bytes_allocated < root->sectorsize) {
7790 data_bytes_referenced +=
7791 btrfs_file_extent_num_bytes(buf, fi);
7792 add_data_backref(extent_cache,
7793 btrfs_file_extent_disk_bytenr(buf, fi),
7794 parent, owner, key.objectid, key.offset -
7795 btrfs_file_extent_offset(buf, fi), 1, 1,
7796 btrfs_file_extent_disk_num_bytes(buf, fi));
7800 struct btrfs_key first_key;
7802 first_key.objectid = 0;
7805 btrfs_item_key_to_cpu(buf, &first_key, 0);
7806 level = btrfs_header_level(buf);
7807 for (i = 0; i < nritems; i++) {
7808 struct extent_record tmpl;
7810 ptr = btrfs_node_blockptr(buf, i);
7811 size = root->nodesize;
7812 btrfs_node_key_to_cpu(buf, &key, i);
7814 if ((level == ri->drop_level)
7815 && is_dropped_key(&key, &ri->drop_key)) {
7820 memset(&tmpl, 0, sizeof(tmpl));
7821 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7822 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7827 tmpl.max_size = size;
7828 ret = add_extent_rec(extent_cache, &tmpl);
7832 ret = add_tree_backref(extent_cache, ptr, parent,
7835 error("add_tree_backref failed: %s",
7841 add_pending(nodes, seen, ptr, size);
7843 add_pending(pending, seen, ptr, size);
7846 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7847 nritems) * sizeof(struct btrfs_key_ptr);
7849 total_btree_bytes += buf->len;
7850 if (fs_root_objectid(btrfs_header_owner(buf)))
7851 total_fs_tree_bytes += buf->len;
7852 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7853 total_extent_tree_bytes += buf->len;
7854 if (!found_old_backref &&
7855 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7856 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7857 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7858 found_old_backref = 1;
7860 free_extent_buffer(buf);
7864 static int add_root_to_pending(struct extent_buffer *buf,
7865 struct cache_tree *extent_cache,
7866 struct cache_tree *pending,
7867 struct cache_tree *seen,
7868 struct cache_tree *nodes,
7871 struct extent_record tmpl;
7874 if (btrfs_header_level(buf) > 0)
7875 add_pending(nodes, seen, buf->start, buf->len);
7877 add_pending(pending, seen, buf->start, buf->len);
7879 memset(&tmpl, 0, sizeof(tmpl));
7880 tmpl.start = buf->start;
7885 tmpl.max_size = buf->len;
7886 add_extent_rec(extent_cache, &tmpl);
7888 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7889 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7890 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7893 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7898 /* as we fix the tree, we might be deleting blocks that
7899 * we're tracking for repair. This hook makes sure we
7900 * remove any backrefs for blocks as we are fixing them.
7902 static int free_extent_hook(struct btrfs_trans_handle *trans,
7903 struct btrfs_root *root,
7904 u64 bytenr, u64 num_bytes, u64 parent,
7905 u64 root_objectid, u64 owner, u64 offset,
7908 struct extent_record *rec;
7909 struct cache_extent *cache;
7911 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
7913 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
7914 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
7918 rec = container_of(cache, struct extent_record, cache);
7920 struct data_backref *back;
7921 back = find_data_backref(rec, parent, root_objectid, owner,
7922 offset, 1, bytenr, num_bytes);
7925 if (back->node.found_ref) {
7926 back->found_ref -= refs_to_drop;
7928 rec->refs -= refs_to_drop;
7930 if (back->node.found_extent_tree) {
7931 back->num_refs -= refs_to_drop;
7932 if (rec->extent_item_refs)
7933 rec->extent_item_refs -= refs_to_drop;
7935 if (back->found_ref == 0)
7936 back->node.found_ref = 0;
7937 if (back->num_refs == 0)
7938 back->node.found_extent_tree = 0;
7940 if (!back->node.found_extent_tree && back->node.found_ref) {
7941 list_del(&back->node.list);
7945 struct tree_backref *back;
7946 back = find_tree_backref(rec, parent, root_objectid);
7949 if (back->node.found_ref) {
7952 back->node.found_ref = 0;
7954 if (back->node.found_extent_tree) {
7955 if (rec->extent_item_refs)
7956 rec->extent_item_refs--;
7957 back->node.found_extent_tree = 0;
7959 if (!back->node.found_extent_tree && back->node.found_ref) {
7960 list_del(&back->node.list);
7964 maybe_free_extent_rec(extent_cache, rec);
7969 static int delete_extent_records(struct btrfs_trans_handle *trans,
7970 struct btrfs_root *root,
7971 struct btrfs_path *path,
7972 u64 bytenr, u64 new_len)
7974 struct btrfs_key key;
7975 struct btrfs_key found_key;
7976 struct extent_buffer *leaf;
7981 key.objectid = bytenr;
7983 key.offset = (u64)-1;
7986 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
7993 if (path->slots[0] == 0)
7999 leaf = path->nodes[0];
8000 slot = path->slots[0];
8002 btrfs_item_key_to_cpu(leaf, &found_key, slot);
8003 if (found_key.objectid != bytenr)
8006 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
8007 found_key.type != BTRFS_METADATA_ITEM_KEY &&
8008 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
8009 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
8010 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
8011 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
8012 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
8013 btrfs_release_path(path);
8014 if (found_key.type == 0) {
8015 if (found_key.offset == 0)
8017 key.offset = found_key.offset - 1;
8018 key.type = found_key.type;
8020 key.type = found_key.type - 1;
8021 key.offset = (u64)-1;
8025 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8026 found_key.objectid, found_key.type, found_key.offset);
8028 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8031 btrfs_release_path(path);
8033 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8034 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8035 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8036 found_key.offset : root->nodesize;
8038 ret = btrfs_update_block_group(trans, root, bytenr,
8045 btrfs_release_path(path);
8050 * for a single backref, this will allocate a new extent
8051 * and add the backref to it.
8053 static int record_extent(struct btrfs_trans_handle *trans,
8054 struct btrfs_fs_info *info,
8055 struct btrfs_path *path,
8056 struct extent_record *rec,
8057 struct extent_backref *back,
8058 int allocated, u64 flags)
8061 struct btrfs_root *extent_root = info->extent_root;
8062 struct extent_buffer *leaf;
8063 struct btrfs_key ins_key;
8064 struct btrfs_extent_item *ei;
8065 struct data_backref *dback;
8066 struct btrfs_tree_block_info *bi;
8069 rec->max_size = max_t(u64, rec->max_size,
8070 info->extent_root->nodesize);
8073 u32 item_size = sizeof(*ei);
8076 item_size += sizeof(*bi);
8078 ins_key.objectid = rec->start;
8079 ins_key.offset = rec->max_size;
8080 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8082 ret = btrfs_insert_empty_item(trans, extent_root, path,
8083 &ins_key, item_size);
8087 leaf = path->nodes[0];
8088 ei = btrfs_item_ptr(leaf, path->slots[0],
8089 struct btrfs_extent_item);
8091 btrfs_set_extent_refs(leaf, ei, 0);
8092 btrfs_set_extent_generation(leaf, ei, rec->generation);
8094 if (back->is_data) {
8095 btrfs_set_extent_flags(leaf, ei,
8096 BTRFS_EXTENT_FLAG_DATA);
8098 struct btrfs_disk_key copy_key;;
8100 bi = (struct btrfs_tree_block_info *)(ei + 1);
8101 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8104 btrfs_set_disk_key_objectid(©_key,
8105 rec->info_objectid);
8106 btrfs_set_disk_key_type(©_key, 0);
8107 btrfs_set_disk_key_offset(©_key, 0);
8109 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8110 btrfs_set_tree_block_key(leaf, bi, ©_key);
8112 btrfs_set_extent_flags(leaf, ei,
8113 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8116 btrfs_mark_buffer_dirty(leaf);
8117 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8118 rec->max_size, 1, 0);
8121 btrfs_release_path(path);
8124 if (back->is_data) {
8128 dback = to_data_backref(back);
8129 if (back->full_backref)
8130 parent = dback->parent;
8134 for (i = 0; i < dback->found_ref; i++) {
8135 /* if parent != 0, we're doing a full backref
8136 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8137 * just makes the backref allocator create a data
8140 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8141 rec->start, rec->max_size,
8145 BTRFS_FIRST_FREE_OBJECTID :
8151 fprintf(stderr, "adding new data backref"
8152 " on %llu %s %llu owner %llu"
8153 " offset %llu found %d\n",
8154 (unsigned long long)rec->start,
8155 back->full_backref ?
8157 back->full_backref ?
8158 (unsigned long long)parent :
8159 (unsigned long long)dback->root,
8160 (unsigned long long)dback->owner,
8161 (unsigned long long)dback->offset,
8165 struct tree_backref *tback;
8167 tback = to_tree_backref(back);
8168 if (back->full_backref)
8169 parent = tback->parent;
8173 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8174 rec->start, rec->max_size,
8175 parent, tback->root, 0, 0);
8176 fprintf(stderr, "adding new tree backref on "
8177 "start %llu len %llu parent %llu root %llu\n",
8178 rec->start, rec->max_size, parent, tback->root);
8181 btrfs_release_path(path);
8185 static struct extent_entry *find_entry(struct list_head *entries,
8186 u64 bytenr, u64 bytes)
8188 struct extent_entry *entry = NULL;
8190 list_for_each_entry(entry, entries, list) {
8191 if (entry->bytenr == bytenr && entry->bytes == bytes)
8198 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8200 struct extent_entry *entry, *best = NULL, *prev = NULL;
8202 list_for_each_entry(entry, entries, list) {
8204 * If there are as many broken entries as entries then we know
8205 * not to trust this particular entry.
8207 if (entry->broken == entry->count)
8211 * Special case, when there are only two entries and 'best' is
8221 * If our current entry == best then we can't be sure our best
8222 * is really the best, so we need to keep searching.
8224 if (best && best->count == entry->count) {
8230 /* Prev == entry, not good enough, have to keep searching */
8231 if (!prev->broken && prev->count == entry->count)
8235 best = (prev->count > entry->count) ? prev : entry;
8236 else if (best->count < entry->count)
8244 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8245 struct data_backref *dback, struct extent_entry *entry)
8247 struct btrfs_trans_handle *trans;
8248 struct btrfs_root *root;
8249 struct btrfs_file_extent_item *fi;
8250 struct extent_buffer *leaf;
8251 struct btrfs_key key;
8255 key.objectid = dback->root;
8256 key.type = BTRFS_ROOT_ITEM_KEY;
8257 key.offset = (u64)-1;
8258 root = btrfs_read_fs_root(info, &key);
8260 fprintf(stderr, "Couldn't find root for our ref\n");
8265 * The backref points to the original offset of the extent if it was
8266 * split, so we need to search down to the offset we have and then walk
8267 * forward until we find the backref we're looking for.
8269 key.objectid = dback->owner;
8270 key.type = BTRFS_EXTENT_DATA_KEY;
8271 key.offset = dback->offset;
8272 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8274 fprintf(stderr, "Error looking up ref %d\n", ret);
8279 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8280 ret = btrfs_next_leaf(root, path);
8282 fprintf(stderr, "Couldn't find our ref, next\n");
8286 leaf = path->nodes[0];
8287 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8288 if (key.objectid != dback->owner ||
8289 key.type != BTRFS_EXTENT_DATA_KEY) {
8290 fprintf(stderr, "Couldn't find our ref, search\n");
8293 fi = btrfs_item_ptr(leaf, path->slots[0],
8294 struct btrfs_file_extent_item);
8295 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8296 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8298 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8303 btrfs_release_path(path);
8305 trans = btrfs_start_transaction(root, 1);
8307 return PTR_ERR(trans);
8310 * Ok we have the key of the file extent we want to fix, now we can cow
8311 * down to the thing and fix it.
8313 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8315 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8316 key.objectid, key.type, key.offset, ret);
8320 fprintf(stderr, "Well that's odd, we just found this key "
8321 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8326 leaf = path->nodes[0];
8327 fi = btrfs_item_ptr(leaf, path->slots[0],
8328 struct btrfs_file_extent_item);
8330 if (btrfs_file_extent_compression(leaf, fi) &&
8331 dback->disk_bytenr != entry->bytenr) {
8332 fprintf(stderr, "Ref doesn't match the record start and is "
8333 "compressed, please take a btrfs-image of this file "
8334 "system and send it to a btrfs developer so they can "
8335 "complete this functionality for bytenr %Lu\n",
8336 dback->disk_bytenr);
8341 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8342 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8343 } else if (dback->disk_bytenr > entry->bytenr) {
8344 u64 off_diff, offset;
8346 off_diff = dback->disk_bytenr - entry->bytenr;
8347 offset = btrfs_file_extent_offset(leaf, fi);
8348 if (dback->disk_bytenr + offset +
8349 btrfs_file_extent_num_bytes(leaf, fi) >
8350 entry->bytenr + entry->bytes) {
8351 fprintf(stderr, "Ref is past the entry end, please "
8352 "take a btrfs-image of this file system and "
8353 "send it to a btrfs developer, ref %Lu\n",
8354 dback->disk_bytenr);
8359 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8360 btrfs_set_file_extent_offset(leaf, fi, offset);
8361 } else if (dback->disk_bytenr < entry->bytenr) {
8364 offset = btrfs_file_extent_offset(leaf, fi);
8365 if (dback->disk_bytenr + offset < entry->bytenr) {
8366 fprintf(stderr, "Ref is before the entry start, please"
8367 " take a btrfs-image of this file system and "
8368 "send it to a btrfs developer, ref %Lu\n",
8369 dback->disk_bytenr);
8374 offset += dback->disk_bytenr;
8375 offset -= entry->bytenr;
8376 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8377 btrfs_set_file_extent_offset(leaf, fi, offset);
8380 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8383 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8384 * only do this if we aren't using compression, otherwise it's a
8387 if (!btrfs_file_extent_compression(leaf, fi))
8388 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8390 printf("ram bytes may be wrong?\n");
8391 btrfs_mark_buffer_dirty(leaf);
8393 err = btrfs_commit_transaction(trans, root);
8394 btrfs_release_path(path);
8395 return ret ? ret : err;
8398 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8399 struct extent_record *rec)
8401 struct extent_backref *back;
8402 struct data_backref *dback;
8403 struct extent_entry *entry, *best = NULL;
8406 int broken_entries = 0;
8411 * Metadata is easy and the backrefs should always agree on bytenr and
8412 * size, if not we've got bigger issues.
8417 list_for_each_entry(back, &rec->backrefs, list) {
8418 if (back->full_backref || !back->is_data)
8421 dback = to_data_backref(back);
8424 * We only pay attention to backrefs that we found a real
8427 if (dback->found_ref == 0)
8431 * For now we only catch when the bytes don't match, not the
8432 * bytenr. We can easily do this at the same time, but I want
8433 * to have a fs image to test on before we just add repair
8434 * functionality willy-nilly so we know we won't screw up the
8438 entry = find_entry(&entries, dback->disk_bytenr,
8441 entry = malloc(sizeof(struct extent_entry));
8446 memset(entry, 0, sizeof(*entry));
8447 entry->bytenr = dback->disk_bytenr;
8448 entry->bytes = dback->bytes;
8449 list_add_tail(&entry->list, &entries);
8454 * If we only have on entry we may think the entries agree when
8455 * in reality they don't so we have to do some extra checking.
8457 if (dback->disk_bytenr != rec->start ||
8458 dback->bytes != rec->nr || back->broken)
8469 /* Yay all the backrefs agree, carry on good sir */
8470 if (nr_entries <= 1 && !mismatch)
8473 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8474 "%Lu\n", rec->start);
8477 * First we want to see if the backrefs can agree amongst themselves who
8478 * is right, so figure out which one of the entries has the highest
8481 best = find_most_right_entry(&entries);
8484 * Ok so we may have an even split between what the backrefs think, so
8485 * this is where we use the extent ref to see what it thinks.
8488 entry = find_entry(&entries, rec->start, rec->nr);
8489 if (!entry && (!broken_entries || !rec->found_rec)) {
8490 fprintf(stderr, "Backrefs don't agree with each other "
8491 "and extent record doesn't agree with anybody,"
8492 " so we can't fix bytenr %Lu bytes %Lu\n",
8493 rec->start, rec->nr);
8496 } else if (!entry) {
8498 * Ok our backrefs were broken, we'll assume this is the
8499 * correct value and add an entry for this range.
8501 entry = malloc(sizeof(struct extent_entry));
8506 memset(entry, 0, sizeof(*entry));
8507 entry->bytenr = rec->start;
8508 entry->bytes = rec->nr;
8509 list_add_tail(&entry->list, &entries);
8513 best = find_most_right_entry(&entries);
8515 fprintf(stderr, "Backrefs and extent record evenly "
8516 "split on who is right, this is going to "
8517 "require user input to fix bytenr %Lu bytes "
8518 "%Lu\n", rec->start, rec->nr);
8525 * I don't think this can happen currently as we'll abort() if we catch
8526 * this case higher up, but in case somebody removes that we still can't
8527 * deal with it properly here yet, so just bail out of that's the case.
8529 if (best->bytenr != rec->start) {
8530 fprintf(stderr, "Extent start and backref starts don't match, "
8531 "please use btrfs-image on this file system and send "
8532 "it to a btrfs developer so they can make fsck fix "
8533 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8534 rec->start, rec->nr);
8540 * Ok great we all agreed on an extent record, let's go find the real
8541 * references and fix up the ones that don't match.
8543 list_for_each_entry(back, &rec->backrefs, list) {
8544 if (back->full_backref || !back->is_data)
8547 dback = to_data_backref(back);
8550 * Still ignoring backrefs that don't have a real ref attached
8553 if (dback->found_ref == 0)
8556 if (dback->bytes == best->bytes &&
8557 dback->disk_bytenr == best->bytenr)
8560 ret = repair_ref(info, path, dback, best);
8566 * Ok we messed with the actual refs, which means we need to drop our
8567 * entire cache and go back and rescan. I know this is a huge pain and
8568 * adds a lot of extra work, but it's the only way to be safe. Once all
8569 * the backrefs agree we may not need to do anything to the extent
8574 while (!list_empty(&entries)) {
8575 entry = list_entry(entries.next, struct extent_entry, list);
8576 list_del_init(&entry->list);
8582 static int process_duplicates(struct btrfs_root *root,
8583 struct cache_tree *extent_cache,
8584 struct extent_record *rec)
8586 struct extent_record *good, *tmp;
8587 struct cache_extent *cache;
8591 * If we found a extent record for this extent then return, or if we
8592 * have more than one duplicate we are likely going to need to delete
8595 if (rec->found_rec || rec->num_duplicates > 1)
8598 /* Shouldn't happen but just in case */
8599 BUG_ON(!rec->num_duplicates);
8602 * So this happens if we end up with a backref that doesn't match the
8603 * actual extent entry. So either the backref is bad or the extent
8604 * entry is bad. Either way we want to have the extent_record actually
8605 * reflect what we found in the extent_tree, so we need to take the
8606 * duplicate out and use that as the extent_record since the only way we
8607 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8609 remove_cache_extent(extent_cache, &rec->cache);
8611 good = to_extent_record(rec->dups.next);
8612 list_del_init(&good->list);
8613 INIT_LIST_HEAD(&good->backrefs);
8614 INIT_LIST_HEAD(&good->dups);
8615 good->cache.start = good->start;
8616 good->cache.size = good->nr;
8617 good->content_checked = 0;
8618 good->owner_ref_checked = 0;
8619 good->num_duplicates = 0;
8620 good->refs = rec->refs;
8621 list_splice_init(&rec->backrefs, &good->backrefs);
8623 cache = lookup_cache_extent(extent_cache, good->start,
8627 tmp = container_of(cache, struct extent_record, cache);
8630 * If we find another overlapping extent and it's found_rec is
8631 * set then it's a duplicate and we need to try and delete
8634 if (tmp->found_rec || tmp->num_duplicates > 0) {
8635 if (list_empty(&good->list))
8636 list_add_tail(&good->list,
8637 &duplicate_extents);
8638 good->num_duplicates += tmp->num_duplicates + 1;
8639 list_splice_init(&tmp->dups, &good->dups);
8640 list_del_init(&tmp->list);
8641 list_add_tail(&tmp->list, &good->dups);
8642 remove_cache_extent(extent_cache, &tmp->cache);
8647 * Ok we have another non extent item backed extent rec, so lets
8648 * just add it to this extent and carry on like we did above.
8650 good->refs += tmp->refs;
8651 list_splice_init(&tmp->backrefs, &good->backrefs);
8652 remove_cache_extent(extent_cache, &tmp->cache);
8655 ret = insert_cache_extent(extent_cache, &good->cache);
8658 return good->num_duplicates ? 0 : 1;
8661 static int delete_duplicate_records(struct btrfs_root *root,
8662 struct extent_record *rec)
8664 struct btrfs_trans_handle *trans;
8665 LIST_HEAD(delete_list);
8666 struct btrfs_path path;
8667 struct extent_record *tmp, *good, *n;
8670 struct btrfs_key key;
8672 btrfs_init_path(&path);
8675 /* Find the record that covers all of the duplicates. */
8676 list_for_each_entry(tmp, &rec->dups, list) {
8677 if (good->start < tmp->start)
8679 if (good->nr > tmp->nr)
8682 if (tmp->start + tmp->nr < good->start + good->nr) {
8683 fprintf(stderr, "Ok we have overlapping extents that "
8684 "aren't completely covered by each other, this "
8685 "is going to require more careful thought. "
8686 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8687 tmp->start, tmp->nr, good->start, good->nr);
8694 list_add_tail(&rec->list, &delete_list);
8696 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8699 list_move_tail(&tmp->list, &delete_list);
8702 root = root->fs_info->extent_root;
8703 trans = btrfs_start_transaction(root, 1);
8704 if (IS_ERR(trans)) {
8705 ret = PTR_ERR(trans);
8709 list_for_each_entry(tmp, &delete_list, list) {
8710 if (tmp->found_rec == 0)
8712 key.objectid = tmp->start;
8713 key.type = BTRFS_EXTENT_ITEM_KEY;
8714 key.offset = tmp->nr;
8716 /* Shouldn't happen but just in case */
8717 if (tmp->metadata) {
8718 fprintf(stderr, "Well this shouldn't happen, extent "
8719 "record overlaps but is metadata? "
8720 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8724 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8730 ret = btrfs_del_item(trans, root, &path);
8733 btrfs_release_path(&path);
8736 err = btrfs_commit_transaction(trans, root);
8740 while (!list_empty(&delete_list)) {
8741 tmp = to_extent_record(delete_list.next);
8742 list_del_init(&tmp->list);
8748 while (!list_empty(&rec->dups)) {
8749 tmp = to_extent_record(rec->dups.next);
8750 list_del_init(&tmp->list);
8754 btrfs_release_path(&path);
8756 if (!ret && !nr_del)
8757 rec->num_duplicates = 0;
8759 return ret ? ret : nr_del;
8762 static int find_possible_backrefs(struct btrfs_fs_info *info,
8763 struct btrfs_path *path,
8764 struct cache_tree *extent_cache,
8765 struct extent_record *rec)
8767 struct btrfs_root *root;
8768 struct extent_backref *back;
8769 struct data_backref *dback;
8770 struct cache_extent *cache;
8771 struct btrfs_file_extent_item *fi;
8772 struct btrfs_key key;
8776 list_for_each_entry(back, &rec->backrefs, list) {
8777 /* Don't care about full backrefs (poor unloved backrefs) */
8778 if (back->full_backref || !back->is_data)
8781 dback = to_data_backref(back);
8783 /* We found this one, we don't need to do a lookup */
8784 if (dback->found_ref)
8787 key.objectid = dback->root;
8788 key.type = BTRFS_ROOT_ITEM_KEY;
8789 key.offset = (u64)-1;
8791 root = btrfs_read_fs_root(info, &key);
8793 /* No root, definitely a bad ref, skip */
8794 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8796 /* Other err, exit */
8798 return PTR_ERR(root);
8800 key.objectid = dback->owner;
8801 key.type = BTRFS_EXTENT_DATA_KEY;
8802 key.offset = dback->offset;
8803 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8805 btrfs_release_path(path);
8808 /* Didn't find it, we can carry on */
8813 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8814 struct btrfs_file_extent_item);
8815 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8816 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8817 btrfs_release_path(path);
8818 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8820 struct extent_record *tmp;
8821 tmp = container_of(cache, struct extent_record, cache);
8824 * If we found an extent record for the bytenr for this
8825 * particular backref then we can't add it to our
8826 * current extent record. We only want to add backrefs
8827 * that don't have a corresponding extent item in the
8828 * extent tree since they likely belong to this record
8829 * and we need to fix it if it doesn't match bytenrs.
8835 dback->found_ref += 1;
8836 dback->disk_bytenr = bytenr;
8837 dback->bytes = bytes;
8840 * Set this so the verify backref code knows not to trust the
8841 * values in this backref.
8850 * Record orphan data ref into corresponding root.
8852 * Return 0 if the extent item contains data ref and recorded.
8853 * Return 1 if the extent item contains no useful data ref
8854 * On that case, it may contains only shared_dataref or metadata backref
8855 * or the file extent exists(this should be handled by the extent bytenr
8857 * Return <0 if something goes wrong.
8859 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8860 struct extent_record *rec)
8862 struct btrfs_key key;
8863 struct btrfs_root *dest_root;
8864 struct extent_backref *back;
8865 struct data_backref *dback;
8866 struct orphan_data_extent *orphan;
8867 struct btrfs_path path;
8868 int recorded_data_ref = 0;
8873 btrfs_init_path(&path);
8874 list_for_each_entry(back, &rec->backrefs, list) {
8875 if (back->full_backref || !back->is_data ||
8876 !back->found_extent_tree)
8878 dback = to_data_backref(back);
8879 if (dback->found_ref)
8881 key.objectid = dback->root;
8882 key.type = BTRFS_ROOT_ITEM_KEY;
8883 key.offset = (u64)-1;
8885 dest_root = btrfs_read_fs_root(fs_info, &key);
8887 /* For non-exist root we just skip it */
8888 if (IS_ERR(dest_root) || !dest_root)
8891 key.objectid = dback->owner;
8892 key.type = BTRFS_EXTENT_DATA_KEY;
8893 key.offset = dback->offset;
8895 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8896 btrfs_release_path(&path);
8898 * For ret < 0, it's OK since the fs-tree may be corrupted,
8899 * we need to record it for inode/file extent rebuild.
8900 * For ret > 0, we record it only for file extent rebuild.
8901 * For ret == 0, the file extent exists but only bytenr
8902 * mismatch, let the original bytenr fix routine to handle,
8908 orphan = malloc(sizeof(*orphan));
8913 INIT_LIST_HEAD(&orphan->list);
8914 orphan->root = dback->root;
8915 orphan->objectid = dback->owner;
8916 orphan->offset = dback->offset;
8917 orphan->disk_bytenr = rec->cache.start;
8918 orphan->disk_len = rec->cache.size;
8919 list_add(&dest_root->orphan_data_extents, &orphan->list);
8920 recorded_data_ref = 1;
8923 btrfs_release_path(&path);
8925 return !recorded_data_ref;
8931 * when an incorrect extent item is found, this will delete
8932 * all of the existing entries for it and recreate them
8933 * based on what the tree scan found.
8935 static int fixup_extent_refs(struct btrfs_fs_info *info,
8936 struct cache_tree *extent_cache,
8937 struct extent_record *rec)
8939 struct btrfs_trans_handle *trans = NULL;
8941 struct btrfs_path path;
8942 struct list_head *cur = rec->backrefs.next;
8943 struct cache_extent *cache;
8944 struct extent_backref *back;
8948 if (rec->flag_block_full_backref)
8949 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
8951 btrfs_init_path(&path);
8952 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
8954 * Sometimes the backrefs themselves are so broken they don't
8955 * get attached to any meaningful rec, so first go back and
8956 * check any of our backrefs that we couldn't find and throw
8957 * them into the list if we find the backref so that
8958 * verify_backrefs can figure out what to do.
8960 ret = find_possible_backrefs(info, &path, extent_cache, rec);
8965 /* step one, make sure all of the backrefs agree */
8966 ret = verify_backrefs(info, &path, rec);
8970 trans = btrfs_start_transaction(info->extent_root, 1);
8971 if (IS_ERR(trans)) {
8972 ret = PTR_ERR(trans);
8976 /* step two, delete all the existing records */
8977 ret = delete_extent_records(trans, info->extent_root, &path,
8978 rec->start, rec->max_size);
8983 /* was this block corrupt? If so, don't add references to it */
8984 cache = lookup_cache_extent(info->corrupt_blocks,
8985 rec->start, rec->max_size);
8991 /* step three, recreate all the refs we did find */
8992 while(cur != &rec->backrefs) {
8993 back = to_extent_backref(cur);
8997 * if we didn't find any references, don't create a
9000 if (!back->found_ref)
9003 rec->bad_full_backref = 0;
9004 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
9012 int err = btrfs_commit_transaction(trans, info->extent_root);
9018 fprintf(stderr, "Repaired extent references for %llu\n",
9019 (unsigned long long)rec->start);
9021 btrfs_release_path(&path);
9025 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9026 struct extent_record *rec)
9028 struct btrfs_trans_handle *trans;
9029 struct btrfs_root *root = fs_info->extent_root;
9030 struct btrfs_path path;
9031 struct btrfs_extent_item *ei;
9032 struct btrfs_key key;
9036 key.objectid = rec->start;
9037 if (rec->metadata) {
9038 key.type = BTRFS_METADATA_ITEM_KEY;
9039 key.offset = rec->info_level;
9041 key.type = BTRFS_EXTENT_ITEM_KEY;
9042 key.offset = rec->max_size;
9045 trans = btrfs_start_transaction(root, 0);
9047 return PTR_ERR(trans);
9049 btrfs_init_path(&path);
9050 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9052 btrfs_release_path(&path);
9053 btrfs_commit_transaction(trans, root);
9056 fprintf(stderr, "Didn't find extent for %llu\n",
9057 (unsigned long long)rec->start);
9058 btrfs_release_path(&path);
9059 btrfs_commit_transaction(trans, root);
9063 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9064 struct btrfs_extent_item);
9065 flags = btrfs_extent_flags(path.nodes[0], ei);
9066 if (rec->flag_block_full_backref) {
9067 fprintf(stderr, "setting full backref on %llu\n",
9068 (unsigned long long)key.objectid);
9069 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9071 fprintf(stderr, "clearing full backref on %llu\n",
9072 (unsigned long long)key.objectid);
9073 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9075 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9076 btrfs_mark_buffer_dirty(path.nodes[0]);
9077 btrfs_release_path(&path);
9078 ret = btrfs_commit_transaction(trans, root);
9080 fprintf(stderr, "Repaired extent flags for %llu\n",
9081 (unsigned long long)rec->start);
9086 /* right now we only prune from the extent allocation tree */
9087 static int prune_one_block(struct btrfs_trans_handle *trans,
9088 struct btrfs_fs_info *info,
9089 struct btrfs_corrupt_block *corrupt)
9092 struct btrfs_path path;
9093 struct extent_buffer *eb;
9097 int level = corrupt->level + 1;
9099 btrfs_init_path(&path);
9101 /* we want to stop at the parent to our busted block */
9102 path.lowest_level = level;
9104 ret = btrfs_search_slot(trans, info->extent_root,
9105 &corrupt->key, &path, -1, 1);
9110 eb = path.nodes[level];
9117 * hopefully the search gave us the block we want to prune,
9118 * lets try that first
9120 slot = path.slots[level];
9121 found = btrfs_node_blockptr(eb, slot);
9122 if (found == corrupt->cache.start)
9125 nritems = btrfs_header_nritems(eb);
9127 /* the search failed, lets scan this node and hope we find it */
9128 for (slot = 0; slot < nritems; slot++) {
9129 found = btrfs_node_blockptr(eb, slot);
9130 if (found == corrupt->cache.start)
9134 * we couldn't find the bad block. TODO, search all the nodes for pointers
9137 if (eb == info->extent_root->node) {
9142 btrfs_release_path(&path);
9147 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9148 ret = btrfs_del_ptr(trans, info->extent_root, &path, level, slot);
9151 btrfs_release_path(&path);
9155 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9157 struct btrfs_trans_handle *trans = NULL;
9158 struct cache_extent *cache;
9159 struct btrfs_corrupt_block *corrupt;
9162 cache = search_cache_extent(info->corrupt_blocks, 0);
9166 trans = btrfs_start_transaction(info->extent_root, 1);
9168 return PTR_ERR(trans);
9170 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9171 prune_one_block(trans, info, corrupt);
9172 remove_cache_extent(info->corrupt_blocks, cache);
9175 return btrfs_commit_transaction(trans, info->extent_root);
9179 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9181 struct btrfs_block_group_cache *cache;
9186 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9187 &start, &end, EXTENT_DIRTY);
9190 clear_extent_dirty(&fs_info->free_space_cache, start, end,
9196 cache = btrfs_lookup_first_block_group(fs_info, start);
9201 start = cache->key.objectid + cache->key.offset;
9205 static int check_extent_refs(struct btrfs_root *root,
9206 struct cache_tree *extent_cache)
9208 struct extent_record *rec;
9209 struct cache_extent *cache;
9215 * if we're doing a repair, we have to make sure
9216 * we don't allocate from the problem extents.
9217 * In the worst case, this will be all the
9220 cache = search_cache_extent(extent_cache, 0);
9222 rec = container_of(cache, struct extent_record, cache);
9223 set_extent_dirty(root->fs_info->excluded_extents,
9225 rec->start + rec->max_size - 1,
9227 cache = next_cache_extent(cache);
9230 /* pin down all the corrupted blocks too */
9231 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9233 set_extent_dirty(root->fs_info->excluded_extents,
9235 cache->start + cache->size - 1,
9237 cache = next_cache_extent(cache);
9239 prune_corrupt_blocks(root->fs_info);
9240 reset_cached_block_groups(root->fs_info);
9243 reset_cached_block_groups(root->fs_info);
9246 * We need to delete any duplicate entries we find first otherwise we
9247 * could mess up the extent tree when we have backrefs that actually
9248 * belong to a different extent item and not the weird duplicate one.
9250 while (repair && !list_empty(&duplicate_extents)) {
9251 rec = to_extent_record(duplicate_extents.next);
9252 list_del_init(&rec->list);
9254 /* Sometimes we can find a backref before we find an actual
9255 * extent, so we need to process it a little bit to see if there
9256 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9257 * if this is a backref screwup. If we need to delete stuff
9258 * process_duplicates() will return 0, otherwise it will return
9261 if (process_duplicates(root, extent_cache, rec))
9263 ret = delete_duplicate_records(root, rec);
9267 * delete_duplicate_records will return the number of entries
9268 * deleted, so if it's greater than 0 then we know we actually
9269 * did something and we need to remove.
9282 cache = search_cache_extent(extent_cache, 0);
9285 rec = container_of(cache, struct extent_record, cache);
9286 if (rec->num_duplicates) {
9287 fprintf(stderr, "extent item %llu has multiple extent "
9288 "items\n", (unsigned long long)rec->start);
9292 if (rec->refs != rec->extent_item_refs) {
9293 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9294 (unsigned long long)rec->start,
9295 (unsigned long long)rec->nr);
9296 fprintf(stderr, "extent item %llu, found %llu\n",
9297 (unsigned long long)rec->extent_item_refs,
9298 (unsigned long long)rec->refs);
9299 ret = record_orphan_data_extents(root->fs_info, rec);
9305 if (all_backpointers_checked(rec, 1)) {
9306 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9307 (unsigned long long)rec->start,
9308 (unsigned long long)rec->nr);
9312 if (!rec->owner_ref_checked) {
9313 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9314 (unsigned long long)rec->start,
9315 (unsigned long long)rec->nr);
9320 if (repair && fix) {
9321 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9327 if (rec->bad_full_backref) {
9328 fprintf(stderr, "bad full backref, on [%llu]\n",
9329 (unsigned long long)rec->start);
9331 ret = fixup_extent_flags(root->fs_info, rec);
9339 * Although it's not a extent ref's problem, we reuse this
9340 * routine for error reporting.
9341 * No repair function yet.
9343 if (rec->crossing_stripes) {
9345 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9346 rec->start, rec->start + rec->max_size);
9350 if (rec->wrong_chunk_type) {
9352 "bad extent [%llu, %llu), type mismatch with chunk\n",
9353 rec->start, rec->start + rec->max_size);
9357 remove_cache_extent(extent_cache, cache);
9358 free_all_extent_backrefs(rec);
9359 if (!init_extent_tree && repair && (!cur_err || fix))
9360 clear_extent_dirty(root->fs_info->excluded_extents,
9362 rec->start + rec->max_size - 1,
9368 if (ret && ret != -EAGAIN) {
9369 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9372 struct btrfs_trans_handle *trans;
9374 root = root->fs_info->extent_root;
9375 trans = btrfs_start_transaction(root, 1);
9376 if (IS_ERR(trans)) {
9377 ret = PTR_ERR(trans);
9381 btrfs_fix_block_accounting(trans, root);
9382 ret = btrfs_commit_transaction(trans, root);
9391 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9395 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9396 stripe_size = length;
9397 stripe_size /= num_stripes;
9398 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9399 stripe_size = length * 2;
9400 stripe_size /= num_stripes;
9401 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9402 stripe_size = length;
9403 stripe_size /= (num_stripes - 1);
9404 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9405 stripe_size = length;
9406 stripe_size /= (num_stripes - 2);
9408 stripe_size = length;
9414 * Check the chunk with its block group/dev list ref:
9415 * Return 0 if all refs seems valid.
9416 * Return 1 if part of refs seems valid, need later check for rebuild ref
9417 * like missing block group and needs to search extent tree to rebuild them.
9418 * Return -1 if essential refs are missing and unable to rebuild.
9420 static int check_chunk_refs(struct chunk_record *chunk_rec,
9421 struct block_group_tree *block_group_cache,
9422 struct device_extent_tree *dev_extent_cache,
9425 struct cache_extent *block_group_item;
9426 struct block_group_record *block_group_rec;
9427 struct cache_extent *dev_extent_item;
9428 struct device_extent_record *dev_extent_rec;
9432 int metadump_v2 = 0;
9436 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9439 if (block_group_item) {
9440 block_group_rec = container_of(block_group_item,
9441 struct block_group_record,
9443 if (chunk_rec->length != block_group_rec->offset ||
9444 chunk_rec->offset != block_group_rec->objectid ||
9446 chunk_rec->type_flags != block_group_rec->flags)) {
9449 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9450 chunk_rec->objectid,
9455 chunk_rec->type_flags,
9456 block_group_rec->objectid,
9457 block_group_rec->type,
9458 block_group_rec->offset,
9459 block_group_rec->offset,
9460 block_group_rec->objectid,
9461 block_group_rec->flags);
9464 list_del_init(&block_group_rec->list);
9465 chunk_rec->bg_rec = block_group_rec;
9470 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9471 chunk_rec->objectid,
9476 chunk_rec->type_flags);
9483 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9484 chunk_rec->num_stripes);
9485 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9486 devid = chunk_rec->stripes[i].devid;
9487 offset = chunk_rec->stripes[i].offset;
9488 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9489 devid, offset, length);
9490 if (dev_extent_item) {
9491 dev_extent_rec = container_of(dev_extent_item,
9492 struct device_extent_record,
9494 if (dev_extent_rec->objectid != devid ||
9495 dev_extent_rec->offset != offset ||
9496 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9497 dev_extent_rec->length != length) {
9500 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9501 chunk_rec->objectid,
9504 chunk_rec->stripes[i].devid,
9505 chunk_rec->stripes[i].offset,
9506 dev_extent_rec->objectid,
9507 dev_extent_rec->offset,
9508 dev_extent_rec->length);
9511 list_move(&dev_extent_rec->chunk_list,
9512 &chunk_rec->dextents);
9517 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9518 chunk_rec->objectid,
9521 chunk_rec->stripes[i].devid,
9522 chunk_rec->stripes[i].offset);
9529 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9530 int check_chunks(struct cache_tree *chunk_cache,
9531 struct block_group_tree *block_group_cache,
9532 struct device_extent_tree *dev_extent_cache,
9533 struct list_head *good, struct list_head *bad,
9534 struct list_head *rebuild, int silent)
9536 struct cache_extent *chunk_item;
9537 struct chunk_record *chunk_rec;
9538 struct block_group_record *bg_rec;
9539 struct device_extent_record *dext_rec;
9543 chunk_item = first_cache_extent(chunk_cache);
9544 while (chunk_item) {
9545 chunk_rec = container_of(chunk_item, struct chunk_record,
9547 err = check_chunk_refs(chunk_rec, block_group_cache,
9548 dev_extent_cache, silent);
9551 if (err == 0 && good)
9552 list_add_tail(&chunk_rec->list, good);
9553 if (err > 0 && rebuild)
9554 list_add_tail(&chunk_rec->list, rebuild);
9556 list_add_tail(&chunk_rec->list, bad);
9557 chunk_item = next_cache_extent(chunk_item);
9560 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9563 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9571 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9575 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9586 static int check_device_used(struct device_record *dev_rec,
9587 struct device_extent_tree *dext_cache)
9589 struct cache_extent *cache;
9590 struct device_extent_record *dev_extent_rec;
9593 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9595 dev_extent_rec = container_of(cache,
9596 struct device_extent_record,
9598 if (dev_extent_rec->objectid != dev_rec->devid)
9601 list_del_init(&dev_extent_rec->device_list);
9602 total_byte += dev_extent_rec->length;
9603 cache = next_cache_extent(cache);
9606 if (total_byte != dev_rec->byte_used) {
9608 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9609 total_byte, dev_rec->byte_used, dev_rec->objectid,
9610 dev_rec->type, dev_rec->offset);
9617 /* check btrfs_dev_item -> btrfs_dev_extent */
9618 static int check_devices(struct rb_root *dev_cache,
9619 struct device_extent_tree *dev_extent_cache)
9621 struct rb_node *dev_node;
9622 struct device_record *dev_rec;
9623 struct device_extent_record *dext_rec;
9627 dev_node = rb_first(dev_cache);
9629 dev_rec = container_of(dev_node, struct device_record, node);
9630 err = check_device_used(dev_rec, dev_extent_cache);
9634 dev_node = rb_next(dev_node);
9636 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9639 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9640 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9647 static int add_root_item_to_list(struct list_head *head,
9648 u64 objectid, u64 bytenr, u64 last_snapshot,
9649 u8 level, u8 drop_level,
9650 int level_size, struct btrfs_key *drop_key)
9653 struct root_item_record *ri_rec;
9654 ri_rec = malloc(sizeof(*ri_rec));
9657 ri_rec->bytenr = bytenr;
9658 ri_rec->objectid = objectid;
9659 ri_rec->level = level;
9660 ri_rec->level_size = level_size;
9661 ri_rec->drop_level = drop_level;
9662 ri_rec->last_snapshot = last_snapshot;
9664 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9665 list_add_tail(&ri_rec->list, head);
9670 static void free_root_item_list(struct list_head *list)
9672 struct root_item_record *ri_rec;
9674 while (!list_empty(list)) {
9675 ri_rec = list_first_entry(list, struct root_item_record,
9677 list_del_init(&ri_rec->list);
9682 static int deal_root_from_list(struct list_head *list,
9683 struct btrfs_root *root,
9684 struct block_info *bits,
9686 struct cache_tree *pending,
9687 struct cache_tree *seen,
9688 struct cache_tree *reada,
9689 struct cache_tree *nodes,
9690 struct cache_tree *extent_cache,
9691 struct cache_tree *chunk_cache,
9692 struct rb_root *dev_cache,
9693 struct block_group_tree *block_group_cache,
9694 struct device_extent_tree *dev_extent_cache)
9699 while (!list_empty(list)) {
9700 struct root_item_record *rec;
9701 struct extent_buffer *buf;
9702 rec = list_entry(list->next,
9703 struct root_item_record, list);
9705 buf = read_tree_block(root->fs_info->tree_root,
9706 rec->bytenr, rec->level_size, 0);
9707 if (!extent_buffer_uptodate(buf)) {
9708 free_extent_buffer(buf);
9712 ret = add_root_to_pending(buf, extent_cache, pending,
9713 seen, nodes, rec->objectid);
9717 * To rebuild extent tree, we need deal with snapshot
9718 * one by one, otherwise we deal with node firstly which
9719 * can maximize readahead.
9722 ret = run_next_block(root, bits, bits_nr, &last,
9723 pending, seen, reada, nodes,
9724 extent_cache, chunk_cache,
9725 dev_cache, block_group_cache,
9726 dev_extent_cache, rec);
9730 free_extent_buffer(buf);
9731 list_del(&rec->list);
9737 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9738 reada, nodes, extent_cache, chunk_cache,
9739 dev_cache, block_group_cache,
9740 dev_extent_cache, NULL);
9750 static int check_chunks_and_extents(struct btrfs_root *root)
9752 struct rb_root dev_cache;
9753 struct cache_tree chunk_cache;
9754 struct block_group_tree block_group_cache;
9755 struct device_extent_tree dev_extent_cache;
9756 struct cache_tree extent_cache;
9757 struct cache_tree seen;
9758 struct cache_tree pending;
9759 struct cache_tree reada;
9760 struct cache_tree nodes;
9761 struct extent_io_tree excluded_extents;
9762 struct cache_tree corrupt_blocks;
9763 struct btrfs_path path;
9764 struct btrfs_key key;
9765 struct btrfs_key found_key;
9767 struct block_info *bits;
9769 struct extent_buffer *leaf;
9771 struct btrfs_root_item ri;
9772 struct list_head dropping_trees;
9773 struct list_head normal_trees;
9774 struct btrfs_root *root1;
9779 dev_cache = RB_ROOT;
9780 cache_tree_init(&chunk_cache);
9781 block_group_tree_init(&block_group_cache);
9782 device_extent_tree_init(&dev_extent_cache);
9784 cache_tree_init(&extent_cache);
9785 cache_tree_init(&seen);
9786 cache_tree_init(&pending);
9787 cache_tree_init(&nodes);
9788 cache_tree_init(&reada);
9789 cache_tree_init(&corrupt_blocks);
9790 extent_io_tree_init(&excluded_extents);
9791 INIT_LIST_HEAD(&dropping_trees);
9792 INIT_LIST_HEAD(&normal_trees);
9795 root->fs_info->excluded_extents = &excluded_extents;
9796 root->fs_info->fsck_extent_cache = &extent_cache;
9797 root->fs_info->free_extent_hook = free_extent_hook;
9798 root->fs_info->corrupt_blocks = &corrupt_blocks;
9802 bits = malloc(bits_nr * sizeof(struct block_info));
9808 if (ctx.progress_enabled) {
9809 ctx.tp = TASK_EXTENTS;
9810 task_start(ctx.info);
9814 root1 = root->fs_info->tree_root;
9815 level = btrfs_header_level(root1->node);
9816 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9817 root1->node->start, 0, level, 0,
9818 root1->nodesize, NULL);
9821 root1 = root->fs_info->chunk_root;
9822 level = btrfs_header_level(root1->node);
9823 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9824 root1->node->start, 0, level, 0,
9825 root1->nodesize, NULL);
9828 btrfs_init_path(&path);
9831 key.type = BTRFS_ROOT_ITEM_KEY;
9832 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9837 leaf = path.nodes[0];
9838 slot = path.slots[0];
9839 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9840 ret = btrfs_next_leaf(root, &path);
9843 leaf = path.nodes[0];
9844 slot = path.slots[0];
9846 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9847 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9848 unsigned long offset;
9851 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9852 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9853 last_snapshot = btrfs_root_last_snapshot(&ri);
9854 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9855 level = btrfs_root_level(&ri);
9856 level_size = root->nodesize;
9857 ret = add_root_item_to_list(&normal_trees,
9859 btrfs_root_bytenr(&ri),
9860 last_snapshot, level,
9861 0, level_size, NULL);
9865 level = btrfs_root_level(&ri);
9866 level_size = root->nodesize;
9867 objectid = found_key.objectid;
9868 btrfs_disk_key_to_cpu(&found_key,
9870 ret = add_root_item_to_list(&dropping_trees,
9872 btrfs_root_bytenr(&ri),
9873 last_snapshot, level,
9875 level_size, &found_key);
9882 btrfs_release_path(&path);
9885 * check_block can return -EAGAIN if it fixes something, please keep
9886 * this in mind when dealing with return values from these functions, if
9887 * we get -EAGAIN we want to fall through and restart the loop.
9889 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9890 &seen, &reada, &nodes, &extent_cache,
9891 &chunk_cache, &dev_cache, &block_group_cache,
9898 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9899 &pending, &seen, &reada, &nodes,
9900 &extent_cache, &chunk_cache, &dev_cache,
9901 &block_group_cache, &dev_extent_cache);
9908 ret = check_chunks(&chunk_cache, &block_group_cache,
9909 &dev_extent_cache, NULL, NULL, NULL, 0);
9916 ret = check_extent_refs(root, &extent_cache);
9923 ret = check_devices(&dev_cache, &dev_extent_cache);
9928 task_stop(ctx.info);
9930 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9931 extent_io_tree_cleanup(&excluded_extents);
9932 root->fs_info->fsck_extent_cache = NULL;
9933 root->fs_info->free_extent_hook = NULL;
9934 root->fs_info->corrupt_blocks = NULL;
9935 root->fs_info->excluded_extents = NULL;
9938 free_chunk_cache_tree(&chunk_cache);
9939 free_device_cache_tree(&dev_cache);
9940 free_block_group_tree(&block_group_cache);
9941 free_device_extent_tree(&dev_extent_cache);
9942 free_extent_cache_tree(&seen);
9943 free_extent_cache_tree(&pending);
9944 free_extent_cache_tree(&reada);
9945 free_extent_cache_tree(&nodes);
9948 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9949 free_extent_cache_tree(&seen);
9950 free_extent_cache_tree(&pending);
9951 free_extent_cache_tree(&reada);
9952 free_extent_cache_tree(&nodes);
9953 free_chunk_cache_tree(&chunk_cache);
9954 free_block_group_tree(&block_group_cache);
9955 free_device_cache_tree(&dev_cache);
9956 free_device_extent_tree(&dev_extent_cache);
9957 free_extent_record_cache(root->fs_info, &extent_cache);
9958 free_root_item_list(&normal_trees);
9959 free_root_item_list(&dropping_trees);
9960 extent_io_tree_cleanup(&excluded_extents);
9965 * Check backrefs of a tree block given by @bytenr or @eb.
9967 * @root: the root containing the @bytenr or @eb
9968 * @eb: tree block extent buffer, can be NULL
9969 * @bytenr: bytenr of the tree block to search
9970 * @level: tree level of the tree block
9971 * @owner: owner of the tree block
9973 * Return >0 for any error found and output error message
9974 * Return 0 for no error found
9976 static int check_tree_block_ref(struct btrfs_root *root,
9977 struct extent_buffer *eb, u64 bytenr,
9978 int level, u64 owner)
9980 struct btrfs_key key;
9981 struct btrfs_root *extent_root = root->fs_info->extent_root;
9982 struct btrfs_path path;
9983 struct btrfs_extent_item *ei;
9984 struct btrfs_extent_inline_ref *iref;
9985 struct extent_buffer *leaf;
9991 u32 nodesize = root->nodesize;
9994 int tree_reloc_root = 0;
9999 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
10000 btrfs_header_bytenr(root->node) == bytenr)
10001 tree_reloc_root = 1;
10003 btrfs_init_path(&path);
10004 key.objectid = bytenr;
10005 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
10006 key.type = BTRFS_METADATA_ITEM_KEY;
10008 key.type = BTRFS_EXTENT_ITEM_KEY;
10009 key.offset = (u64)-1;
10011 /* Search for the backref in extent tree */
10012 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10014 err |= BACKREF_MISSING;
10017 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10019 err |= BACKREF_MISSING;
10023 leaf = path.nodes[0];
10024 slot = path.slots[0];
10025 btrfs_item_key_to_cpu(leaf, &key, slot);
10027 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10029 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10030 skinny_level = (int)key.offset;
10031 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10033 struct btrfs_tree_block_info *info;
10035 info = (struct btrfs_tree_block_info *)(ei + 1);
10036 skinny_level = btrfs_tree_block_level(leaf, info);
10037 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10044 if (!(btrfs_extent_flags(leaf, ei) &
10045 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10047 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10048 key.objectid, nodesize,
10049 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10050 err = BACKREF_MISMATCH;
10052 header_gen = btrfs_header_generation(eb);
10053 extent_gen = btrfs_extent_generation(leaf, ei);
10054 if (header_gen != extent_gen) {
10056 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10057 key.objectid, nodesize, header_gen,
10059 err = BACKREF_MISMATCH;
10061 if (level != skinny_level) {
10063 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10064 key.objectid, nodesize, level, skinny_level);
10065 err = BACKREF_MISMATCH;
10067 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10069 "extent[%llu %u] is referred by other roots than %llu",
10070 key.objectid, nodesize, root->objectid);
10071 err = BACKREF_MISMATCH;
10076 * Iterate the extent/metadata item to find the exact backref
10078 item_size = btrfs_item_size_nr(leaf, slot);
10079 ptr = (unsigned long)iref;
10080 end = (unsigned long)ei + item_size;
10081 while (ptr < end) {
10082 iref = (struct btrfs_extent_inline_ref *)ptr;
10083 type = btrfs_extent_inline_ref_type(leaf, iref);
10084 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10086 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10087 (offset == root->objectid || offset == owner)) {
10089 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10091 * Backref of tree reloc root points to itself, no need
10092 * to check backref any more.
10094 if (tree_reloc_root)
10097 /* Check if the backref points to valid referencer */
10098 found_ref = !check_tree_block_ref(root, NULL,
10099 offset, level + 1, owner);
10104 ptr += btrfs_extent_inline_ref_size(type);
10108 * Inlined extent item doesn't have what we need, check
10109 * TREE_BLOCK_REF_KEY
10112 btrfs_release_path(&path);
10113 key.objectid = bytenr;
10114 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10115 key.offset = root->objectid;
10117 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10122 err |= BACKREF_MISSING;
10124 btrfs_release_path(&path);
10125 if (eb && (err & BACKREF_MISSING))
10126 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10127 bytenr, nodesize, owner, level);
10132 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10134 * Return >0 any error found and output error message
10135 * Return 0 for no error found
10137 static int check_extent_data_item(struct btrfs_root *root,
10138 struct extent_buffer *eb, int slot)
10140 struct btrfs_file_extent_item *fi;
10141 struct btrfs_path path;
10142 struct btrfs_root *extent_root = root->fs_info->extent_root;
10143 struct btrfs_key fi_key;
10144 struct btrfs_key dbref_key;
10145 struct extent_buffer *leaf;
10146 struct btrfs_extent_item *ei;
10147 struct btrfs_extent_inline_ref *iref;
10148 struct btrfs_extent_data_ref *dref;
10151 u64 disk_num_bytes;
10152 u64 extent_num_bytes;
10159 int found_dbackref = 0;
10163 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10164 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10166 /* Nothing to check for hole and inline data extents */
10167 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10168 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10171 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10172 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10173 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10175 /* Check unaligned disk_num_bytes and num_bytes */
10176 if (!IS_ALIGNED(disk_num_bytes, root->sectorsize)) {
10178 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10179 fi_key.objectid, fi_key.offset, disk_num_bytes,
10181 err |= BYTES_UNALIGNED;
10183 data_bytes_allocated += disk_num_bytes;
10185 if (!IS_ALIGNED(extent_num_bytes, root->sectorsize)) {
10187 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10188 fi_key.objectid, fi_key.offset, extent_num_bytes,
10190 err |= BYTES_UNALIGNED;
10192 data_bytes_referenced += extent_num_bytes;
10194 owner = btrfs_header_owner(eb);
10196 /* Check the extent item of the file extent in extent tree */
10197 btrfs_init_path(&path);
10198 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10199 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10200 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10202 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10204 err |= BACKREF_MISSING;
10208 leaf = path.nodes[0];
10209 slot = path.slots[0];
10210 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10212 extent_flags = btrfs_extent_flags(leaf, ei);
10214 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10216 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10217 disk_bytenr, disk_num_bytes,
10218 BTRFS_EXTENT_FLAG_DATA);
10219 err |= BACKREF_MISMATCH;
10222 /* Check data backref inside that extent item */
10223 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10224 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10225 ptr = (unsigned long)iref;
10226 end = (unsigned long)ei + item_size;
10227 while (ptr < end) {
10228 iref = (struct btrfs_extent_inline_ref *)ptr;
10229 type = btrfs_extent_inline_ref_type(leaf, iref);
10230 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10232 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10233 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10234 if (ref_root == owner || ref_root == root->objectid)
10235 found_dbackref = 1;
10236 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10237 found_dbackref = !check_tree_block_ref(root, NULL,
10238 btrfs_extent_inline_ref_offset(leaf, iref),
10242 if (found_dbackref)
10244 ptr += btrfs_extent_inline_ref_size(type);
10247 /* Didn't found inlined data backref, try EXTENT_DATA_REF_KEY */
10248 if (!found_dbackref) {
10249 btrfs_release_path(&path);
10251 btrfs_init_path(&path);
10252 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10253 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10254 dbref_key.offset = hash_extent_data_ref(root->objectid,
10255 fi_key.objectid, fi_key.offset);
10257 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10258 &dbref_key, &path, 0, 0);
10260 found_dbackref = 1;
10263 if (!found_dbackref)
10264 err |= BACKREF_MISSING;
10266 btrfs_release_path(&path);
10267 if (err & BACKREF_MISSING) {
10268 error("data extent[%llu %llu] backref lost",
10269 disk_bytenr, disk_num_bytes);
10275 * Get real tree block level for the case like shared block
10276 * Return >= 0 as tree level
10277 * Return <0 for error
10279 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10281 struct extent_buffer *eb;
10282 struct btrfs_path path;
10283 struct btrfs_key key;
10284 struct btrfs_extent_item *ei;
10287 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10292 /* Search extent tree for extent generation and level */
10293 key.objectid = bytenr;
10294 key.type = BTRFS_METADATA_ITEM_KEY;
10295 key.offset = (u64)-1;
10297 btrfs_init_path(&path);
10298 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10301 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10309 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10310 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10311 struct btrfs_extent_item);
10312 flags = btrfs_extent_flags(path.nodes[0], ei);
10313 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10318 /* Get transid for later read_tree_block() check */
10319 transid = btrfs_extent_generation(path.nodes[0], ei);
10321 /* Get backref level as one source */
10322 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10323 backref_level = key.offset;
10325 struct btrfs_tree_block_info *info;
10327 info = (struct btrfs_tree_block_info *)(ei + 1);
10328 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10330 btrfs_release_path(&path);
10332 /* Get level from tree block as an alternative source */
10333 eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
10334 if (!extent_buffer_uptodate(eb)) {
10335 free_extent_buffer(eb);
10338 header_level = btrfs_header_level(eb);
10339 free_extent_buffer(eb);
10341 if (header_level != backref_level)
10343 return header_level;
10346 btrfs_release_path(&path);
10351 * Check if a tree block backref is valid (points to a valid tree block)
10352 * if level == -1, level will be resolved
10353 * Return >0 for any error found and print error message
10355 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10356 u64 bytenr, int level)
10358 struct btrfs_root *root;
10359 struct btrfs_key key;
10360 struct btrfs_path path;
10361 struct extent_buffer *eb;
10362 struct extent_buffer *node;
10363 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10367 /* Query level for level == -1 special case */
10369 level = query_tree_block_level(fs_info, bytenr);
10371 err |= REFERENCER_MISSING;
10375 key.objectid = root_id;
10376 key.type = BTRFS_ROOT_ITEM_KEY;
10377 key.offset = (u64)-1;
10379 root = btrfs_read_fs_root(fs_info, &key);
10380 if (IS_ERR(root)) {
10381 err |= REFERENCER_MISSING;
10385 /* Read out the tree block to get item/node key */
10386 eb = read_tree_block(root, bytenr, root->nodesize, 0);
10387 if (!extent_buffer_uptodate(eb)) {
10388 err |= REFERENCER_MISSING;
10389 free_extent_buffer(eb);
10393 /* Empty tree, no need to check key */
10394 if (!btrfs_header_nritems(eb) && !level) {
10395 free_extent_buffer(eb);
10400 btrfs_node_key_to_cpu(eb, &key, 0);
10402 btrfs_item_key_to_cpu(eb, &key, 0);
10404 free_extent_buffer(eb);
10406 btrfs_init_path(&path);
10407 path.lowest_level = level;
10408 /* Search with the first key, to ensure we can reach it */
10409 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10411 err |= REFERENCER_MISSING;
10415 node = path.nodes[level];
10416 if (btrfs_header_bytenr(node) != bytenr) {
10418 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10419 bytenr, nodesize, bytenr,
10420 btrfs_header_bytenr(node));
10421 err |= REFERENCER_MISMATCH;
10423 if (btrfs_header_level(node) != level) {
10425 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10426 bytenr, nodesize, level,
10427 btrfs_header_level(node));
10428 err |= REFERENCER_MISMATCH;
10432 btrfs_release_path(&path);
10434 if (err & REFERENCER_MISSING) {
10436 error("extent [%llu %d] lost referencer (owner: %llu)",
10437 bytenr, nodesize, root_id);
10440 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10441 bytenr, nodesize, root_id, level);
10448 * Check if tree block @eb is tree reloc root.
10449 * Return 0 if it's not or any problem happens
10450 * Return 1 if it's a tree reloc root
10452 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
10453 struct extent_buffer *eb)
10455 struct btrfs_root *tree_reloc_root;
10456 struct btrfs_key key;
10457 u64 bytenr = btrfs_header_bytenr(eb);
10458 u64 owner = btrfs_header_owner(eb);
10461 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
10462 key.offset = owner;
10463 key.type = BTRFS_ROOT_ITEM_KEY;
10465 tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
10466 if (IS_ERR(tree_reloc_root))
10469 if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
10471 btrfs_free_fs_root(tree_reloc_root);
10476 * Check referencer for shared block backref
10477 * If level == -1, this function will resolve the level.
10479 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10480 u64 parent, u64 bytenr, int level)
10482 struct extent_buffer *eb;
10483 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10485 int found_parent = 0;
10488 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10489 if (!extent_buffer_uptodate(eb))
10493 level = query_tree_block_level(fs_info, bytenr);
10497 /* It's possible it's a tree reloc root */
10498 if (parent == bytenr) {
10499 if (is_tree_reloc_root(fs_info, eb))
10504 if (level + 1 != btrfs_header_level(eb))
10507 nr = btrfs_header_nritems(eb);
10508 for (i = 0; i < nr; i++) {
10509 if (bytenr == btrfs_node_blockptr(eb, i)) {
10515 free_extent_buffer(eb);
10516 if (!found_parent) {
10518 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10519 bytenr, nodesize, parent, level);
10520 return REFERENCER_MISSING;
10526 * Check referencer for normal (inlined) data ref
10527 * If len == 0, it will be resolved by searching in extent tree
10529 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10530 u64 root_id, u64 objectid, u64 offset,
10531 u64 bytenr, u64 len, u32 count)
10533 struct btrfs_root *root;
10534 struct btrfs_root *extent_root = fs_info->extent_root;
10535 struct btrfs_key key;
10536 struct btrfs_path path;
10537 struct extent_buffer *leaf;
10538 struct btrfs_file_extent_item *fi;
10539 u32 found_count = 0;
10544 key.objectid = bytenr;
10545 key.type = BTRFS_EXTENT_ITEM_KEY;
10546 key.offset = (u64)-1;
10548 btrfs_init_path(&path);
10549 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10552 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10555 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10556 if (key.objectid != bytenr ||
10557 key.type != BTRFS_EXTENT_ITEM_KEY)
10560 btrfs_release_path(&path);
10562 key.objectid = root_id;
10563 key.type = BTRFS_ROOT_ITEM_KEY;
10564 key.offset = (u64)-1;
10565 btrfs_init_path(&path);
10567 root = btrfs_read_fs_root(fs_info, &key);
10571 key.objectid = objectid;
10572 key.type = BTRFS_EXTENT_DATA_KEY;
10574 * It can be nasty as data backref offset is
10575 * file offset - file extent offset, which is smaller or
10576 * equal to original backref offset. The only special case is
10577 * overflow. So we need to special check and do further search.
10579 key.offset = offset & (1ULL << 63) ? 0 : offset;
10581 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10586 * Search afterwards to get correct one
10587 * NOTE: As we must do a comprehensive check on the data backref to
10588 * make sure the dref count also matches, we must iterate all file
10589 * extents for that inode.
10592 leaf = path.nodes[0];
10593 slot = path.slots[0];
10595 btrfs_item_key_to_cpu(leaf, &key, slot);
10596 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10598 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10600 * Except normal disk bytenr and disk num bytes, we still
10601 * need to do extra check on dbackref offset as
10602 * dbackref offset = file_offset - file_extent_offset
10604 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10605 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10606 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10610 ret = btrfs_next_item(root, &path);
10615 btrfs_release_path(&path);
10616 if (found_count != count) {
10618 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10619 bytenr, len, root_id, objectid, offset, count, found_count);
10620 return REFERENCER_MISSING;
10626 * Check if the referencer of a shared data backref exists
10628 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10629 u64 parent, u64 bytenr)
10631 struct extent_buffer *eb;
10632 struct btrfs_key key;
10633 struct btrfs_file_extent_item *fi;
10634 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10636 int found_parent = 0;
10639 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10640 if (!extent_buffer_uptodate(eb))
10643 nr = btrfs_header_nritems(eb);
10644 for (i = 0; i < nr; i++) {
10645 btrfs_item_key_to_cpu(eb, &key, i);
10646 if (key.type != BTRFS_EXTENT_DATA_KEY)
10649 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10650 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10653 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10660 free_extent_buffer(eb);
10661 if (!found_parent) {
10662 error("shared extent %llu referencer lost (parent: %llu)",
10664 return REFERENCER_MISSING;
10670 * This function will check a given extent item, including its backref and
10671 * itself (like crossing stripe boundary and type)
10673 * Since we don't use extent_record anymore, introduce new error bit
10675 static int check_extent_item(struct btrfs_fs_info *fs_info,
10676 struct extent_buffer *eb, int slot)
10678 struct btrfs_extent_item *ei;
10679 struct btrfs_extent_inline_ref *iref;
10680 struct btrfs_extent_data_ref *dref;
10684 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10685 u32 item_size = btrfs_item_size_nr(eb, slot);
10690 struct btrfs_key key;
10694 btrfs_item_key_to_cpu(eb, &key, slot);
10695 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10696 bytes_used += key.offset;
10698 bytes_used += nodesize;
10700 if (item_size < sizeof(*ei)) {
10702 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10703 * old thing when on disk format is still un-determined.
10704 * No need to care about it anymore
10706 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10710 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10711 flags = btrfs_extent_flags(eb, ei);
10713 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10715 if (metadata && check_crossing_stripes(global_info, key.objectid,
10717 error("bad metadata [%llu, %llu) crossing stripe boundary",
10718 key.objectid, key.objectid + nodesize);
10719 err |= CROSSING_STRIPE_BOUNDARY;
10722 ptr = (unsigned long)(ei + 1);
10724 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10725 /* Old EXTENT_ITEM metadata */
10726 struct btrfs_tree_block_info *info;
10728 info = (struct btrfs_tree_block_info *)ptr;
10729 level = btrfs_tree_block_level(eb, info);
10730 ptr += sizeof(struct btrfs_tree_block_info);
10732 /* New METADATA_ITEM */
10733 level = key.offset;
10735 end = (unsigned long)ei + item_size;
10738 err |= ITEM_SIZE_MISMATCH;
10742 /* Now check every backref in this extent item */
10744 iref = (struct btrfs_extent_inline_ref *)ptr;
10745 type = btrfs_extent_inline_ref_type(eb, iref);
10746 offset = btrfs_extent_inline_ref_offset(eb, iref);
10748 case BTRFS_TREE_BLOCK_REF_KEY:
10749 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10753 case BTRFS_SHARED_BLOCK_REF_KEY:
10754 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10758 case BTRFS_EXTENT_DATA_REF_KEY:
10759 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10760 ret = check_extent_data_backref(fs_info,
10761 btrfs_extent_data_ref_root(eb, dref),
10762 btrfs_extent_data_ref_objectid(eb, dref),
10763 btrfs_extent_data_ref_offset(eb, dref),
10764 key.objectid, key.offset,
10765 btrfs_extent_data_ref_count(eb, dref));
10768 case BTRFS_SHARED_DATA_REF_KEY:
10769 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10773 error("extent[%llu %d %llu] has unknown ref type: %d",
10774 key.objectid, key.type, key.offset, type);
10775 err |= UNKNOWN_TYPE;
10779 ptr += btrfs_extent_inline_ref_size(type);
10788 * Check if a dev extent item is referred correctly by its chunk
10790 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10791 struct extent_buffer *eb, int slot)
10793 struct btrfs_root *chunk_root = fs_info->chunk_root;
10794 struct btrfs_dev_extent *ptr;
10795 struct btrfs_path path;
10796 struct btrfs_key chunk_key;
10797 struct btrfs_key devext_key;
10798 struct btrfs_chunk *chunk;
10799 struct extent_buffer *l;
10803 int found_chunk = 0;
10806 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10807 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10808 length = btrfs_dev_extent_length(eb, ptr);
10810 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10811 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10812 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10814 btrfs_init_path(&path);
10815 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10820 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10821 if (btrfs_chunk_length(l, chunk) != length)
10824 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10825 for (i = 0; i < num_stripes; i++) {
10826 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10827 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10829 if (devid == devext_key.objectid &&
10830 offset == devext_key.offset) {
10836 btrfs_release_path(&path);
10837 if (!found_chunk) {
10839 "device extent[%llu, %llu, %llu] did not find the related chunk",
10840 devext_key.objectid, devext_key.offset, length);
10841 return REFERENCER_MISSING;
10847 * Check if the used space is correct with the dev item
10849 static int check_dev_item(struct btrfs_fs_info *fs_info,
10850 struct extent_buffer *eb, int slot)
10852 struct btrfs_root *dev_root = fs_info->dev_root;
10853 struct btrfs_dev_item *dev_item;
10854 struct btrfs_path path;
10855 struct btrfs_key key;
10856 struct btrfs_dev_extent *ptr;
10862 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10863 dev_id = btrfs_device_id(eb, dev_item);
10864 used = btrfs_device_bytes_used(eb, dev_item);
10866 key.objectid = dev_id;
10867 key.type = BTRFS_DEV_EXTENT_KEY;
10870 btrfs_init_path(&path);
10871 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
10873 btrfs_item_key_to_cpu(eb, &key, slot);
10874 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
10875 key.objectid, key.type, key.offset);
10876 btrfs_release_path(&path);
10877 return REFERENCER_MISSING;
10880 /* Iterate dev_extents to calculate the used space of a device */
10882 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10884 if (key.objectid > dev_id)
10886 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
10889 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
10890 struct btrfs_dev_extent);
10891 total += btrfs_dev_extent_length(path.nodes[0], ptr);
10893 ret = btrfs_next_item(dev_root, &path);
10897 btrfs_release_path(&path);
10899 if (used != total) {
10900 btrfs_item_key_to_cpu(eb, &key, slot);
10902 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
10903 total, used, BTRFS_ROOT_TREE_OBJECTID,
10904 BTRFS_DEV_EXTENT_KEY, dev_id);
10905 return ACCOUNTING_MISMATCH;
10911 * Check a block group item with its referener (chunk) and its used space
10912 * with extent/metadata item
10914 static int check_block_group_item(struct btrfs_fs_info *fs_info,
10915 struct extent_buffer *eb, int slot)
10917 struct btrfs_root *extent_root = fs_info->extent_root;
10918 struct btrfs_root *chunk_root = fs_info->chunk_root;
10919 struct btrfs_block_group_item *bi;
10920 struct btrfs_block_group_item bg_item;
10921 struct btrfs_path path;
10922 struct btrfs_key bg_key;
10923 struct btrfs_key chunk_key;
10924 struct btrfs_key extent_key;
10925 struct btrfs_chunk *chunk;
10926 struct extent_buffer *leaf;
10927 struct btrfs_extent_item *ei;
10928 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10936 btrfs_item_key_to_cpu(eb, &bg_key, slot);
10937 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
10938 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
10939 used = btrfs_block_group_used(&bg_item);
10940 bg_flags = btrfs_block_group_flags(&bg_item);
10942 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
10943 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10944 chunk_key.offset = bg_key.objectid;
10946 btrfs_init_path(&path);
10947 /* Search for the referencer chunk */
10948 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10951 "block group[%llu %llu] did not find the related chunk item",
10952 bg_key.objectid, bg_key.offset);
10953 err |= REFERENCER_MISSING;
10955 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
10956 struct btrfs_chunk);
10957 if (btrfs_chunk_length(path.nodes[0], chunk) !=
10960 "block group[%llu %llu] related chunk item length does not match",
10961 bg_key.objectid, bg_key.offset);
10962 err |= REFERENCER_MISMATCH;
10965 btrfs_release_path(&path);
10967 /* Search from the block group bytenr */
10968 extent_key.objectid = bg_key.objectid;
10969 extent_key.type = 0;
10970 extent_key.offset = 0;
10972 btrfs_init_path(&path);
10973 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
10977 /* Iterate extent tree to account used space */
10979 leaf = path.nodes[0];
10980 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
10981 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
10984 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
10985 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
10987 if (extent_key.objectid < bg_key.objectid)
10990 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
10993 total += extent_key.offset;
10995 ei = btrfs_item_ptr(leaf, path.slots[0],
10996 struct btrfs_extent_item);
10997 flags = btrfs_extent_flags(leaf, ei);
10998 if (flags & BTRFS_EXTENT_FLAG_DATA) {
10999 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
11001 "bad extent[%llu, %llu) type mismatch with chunk",
11002 extent_key.objectid,
11003 extent_key.objectid + extent_key.offset);
11004 err |= CHUNK_TYPE_MISMATCH;
11006 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
11007 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
11008 BTRFS_BLOCK_GROUP_METADATA))) {
11010 "bad extent[%llu, %llu) type mismatch with chunk",
11011 extent_key.objectid,
11012 extent_key.objectid + nodesize);
11013 err |= CHUNK_TYPE_MISMATCH;
11017 ret = btrfs_next_item(extent_root, &path);
11023 btrfs_release_path(&path);
11025 if (total != used) {
11027 "block group[%llu %llu] used %llu but extent items used %llu",
11028 bg_key.objectid, bg_key.offset, used, total);
11029 err |= ACCOUNTING_MISMATCH;
11035 * Check a chunk item.
11036 * Including checking all referred dev_extents and block group
11038 static int check_chunk_item(struct btrfs_fs_info *fs_info,
11039 struct extent_buffer *eb, int slot)
11041 struct btrfs_root *extent_root = fs_info->extent_root;
11042 struct btrfs_root *dev_root = fs_info->dev_root;
11043 struct btrfs_path path;
11044 struct btrfs_key chunk_key;
11045 struct btrfs_key bg_key;
11046 struct btrfs_key devext_key;
11047 struct btrfs_chunk *chunk;
11048 struct extent_buffer *leaf;
11049 struct btrfs_block_group_item *bi;
11050 struct btrfs_block_group_item bg_item;
11051 struct btrfs_dev_extent *ptr;
11052 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
11064 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11065 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11066 length = btrfs_chunk_length(eb, chunk);
11067 chunk_end = chunk_key.offset + length;
11068 if (!IS_ALIGNED(length, sectorsize)) {
11069 error("chunk[%llu %llu) not aligned to %u",
11070 chunk_key.offset, chunk_end, sectorsize);
11071 err |= BYTES_UNALIGNED;
11075 type = btrfs_chunk_type(eb, chunk);
11076 profile = type & BTRFS_BLOCK_GROUP_PROFILE_MASK;
11077 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
11078 error("chunk[%llu %llu) has no chunk type",
11079 chunk_key.offset, chunk_end);
11080 err |= UNKNOWN_TYPE;
11082 if (profile && (profile & (profile - 1))) {
11083 error("chunk[%llu %llu) multiple profiles detected: %llx",
11084 chunk_key.offset, chunk_end, profile);
11085 err |= UNKNOWN_TYPE;
11088 bg_key.objectid = chunk_key.offset;
11089 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11090 bg_key.offset = length;
11092 btrfs_init_path(&path);
11093 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11096 "chunk[%llu %llu) did not find the related block group item",
11097 chunk_key.offset, chunk_end);
11098 err |= REFERENCER_MISSING;
11100 leaf = path.nodes[0];
11101 bi = btrfs_item_ptr(leaf, path.slots[0],
11102 struct btrfs_block_group_item);
11103 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11105 if (btrfs_block_group_flags(&bg_item) != type) {
11107 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11108 chunk_key.offset, chunk_end, type,
11109 btrfs_block_group_flags(&bg_item));
11110 err |= REFERENCER_MISSING;
11114 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11115 for (i = 0; i < num_stripes; i++) {
11116 btrfs_release_path(&path);
11117 btrfs_init_path(&path);
11118 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11119 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11120 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11122 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11125 goto not_match_dev;
11127 leaf = path.nodes[0];
11128 ptr = btrfs_item_ptr(leaf, path.slots[0],
11129 struct btrfs_dev_extent);
11130 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11131 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11132 if (objectid != chunk_key.objectid ||
11133 offset != chunk_key.offset ||
11134 btrfs_dev_extent_length(leaf, ptr) != length)
11135 goto not_match_dev;
11138 err |= BACKREF_MISSING;
11140 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11141 chunk_key.objectid, chunk_end, i);
11144 btrfs_release_path(&path);
11150 * Main entry function to check known items and update related accounting info
11152 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11154 struct btrfs_fs_info *fs_info = root->fs_info;
11155 struct btrfs_key key;
11158 struct btrfs_extent_data_ref *dref;
11163 btrfs_item_key_to_cpu(eb, &key, slot);
11167 case BTRFS_EXTENT_DATA_KEY:
11168 ret = check_extent_data_item(root, eb, slot);
11171 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11172 ret = check_block_group_item(fs_info, eb, slot);
11175 case BTRFS_DEV_ITEM_KEY:
11176 ret = check_dev_item(fs_info, eb, slot);
11179 case BTRFS_CHUNK_ITEM_KEY:
11180 ret = check_chunk_item(fs_info, eb, slot);
11183 case BTRFS_DEV_EXTENT_KEY:
11184 ret = check_dev_extent_item(fs_info, eb, slot);
11187 case BTRFS_EXTENT_ITEM_KEY:
11188 case BTRFS_METADATA_ITEM_KEY:
11189 ret = check_extent_item(fs_info, eb, slot);
11192 case BTRFS_EXTENT_CSUM_KEY:
11193 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11195 case BTRFS_TREE_BLOCK_REF_KEY:
11196 ret = check_tree_block_backref(fs_info, key.offset,
11200 case BTRFS_EXTENT_DATA_REF_KEY:
11201 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11202 ret = check_extent_data_backref(fs_info,
11203 btrfs_extent_data_ref_root(eb, dref),
11204 btrfs_extent_data_ref_objectid(eb, dref),
11205 btrfs_extent_data_ref_offset(eb, dref),
11207 btrfs_extent_data_ref_count(eb, dref));
11210 case BTRFS_SHARED_BLOCK_REF_KEY:
11211 ret = check_shared_block_backref(fs_info, key.offset,
11215 case BTRFS_SHARED_DATA_REF_KEY:
11216 ret = check_shared_data_backref(fs_info, key.offset,
11224 if (++slot < btrfs_header_nritems(eb))
11231 * Helper function for later fs/subvol tree check. To determine if a tree
11232 * block should be checked.
11233 * This function will ensure only the direct referencer with lowest rootid to
11234 * check a fs/subvolume tree block.
11236 * Backref check at extent tree would detect errors like missing subvolume
11237 * tree, so we can do aggressive check to reduce duplicated checks.
11239 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11241 struct btrfs_root *extent_root = root->fs_info->extent_root;
11242 struct btrfs_key key;
11243 struct btrfs_path path;
11244 struct extent_buffer *leaf;
11246 struct btrfs_extent_item *ei;
11252 struct btrfs_extent_inline_ref *iref;
11255 btrfs_init_path(&path);
11256 key.objectid = btrfs_header_bytenr(eb);
11257 key.type = BTRFS_METADATA_ITEM_KEY;
11258 key.offset = (u64)-1;
11261 * Any failure in backref resolving means we can't determine
11262 * whom the tree block belongs to.
11263 * So in that case, we need to check that tree block
11265 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11269 ret = btrfs_previous_extent_item(extent_root, &path,
11270 btrfs_header_bytenr(eb));
11274 leaf = path.nodes[0];
11275 slot = path.slots[0];
11276 btrfs_item_key_to_cpu(leaf, &key, slot);
11277 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11279 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11280 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11282 struct btrfs_tree_block_info *info;
11284 info = (struct btrfs_tree_block_info *)(ei + 1);
11285 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11288 item_size = btrfs_item_size_nr(leaf, slot);
11289 ptr = (unsigned long)iref;
11290 end = (unsigned long)ei + item_size;
11291 while (ptr < end) {
11292 iref = (struct btrfs_extent_inline_ref *)ptr;
11293 type = btrfs_extent_inline_ref_type(leaf, iref);
11294 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11297 * We only check the tree block if current root is
11298 * the lowest referencer of it.
11300 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11301 offset < root->objectid) {
11302 btrfs_release_path(&path);
11306 ptr += btrfs_extent_inline_ref_size(type);
11309 * Normally we should also check keyed tree block ref, but that may be
11310 * very time consuming. Inlined ref should already make us skip a lot
11311 * of refs now. So skip search keyed tree block ref.
11315 btrfs_release_path(&path);
11320 * Traversal function for tree block. We will do:
11321 * 1) Skip shared fs/subvolume tree blocks
11322 * 2) Update related bytes accounting
11323 * 3) Pre-order traversal
11325 static int traverse_tree_block(struct btrfs_root *root,
11326 struct extent_buffer *node)
11328 struct extent_buffer *eb;
11329 struct btrfs_key key;
11330 struct btrfs_key drop_key;
11338 * Skip shared fs/subvolume tree block, in that case they will
11339 * be checked by referencer with lowest rootid
11341 if (is_fstree(root->objectid) && !should_check(root, node))
11344 /* Update bytes accounting */
11345 total_btree_bytes += node->len;
11346 if (fs_root_objectid(btrfs_header_owner(node)))
11347 total_fs_tree_bytes += node->len;
11348 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11349 total_extent_tree_bytes += node->len;
11350 if (!found_old_backref &&
11351 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11352 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11353 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11354 found_old_backref = 1;
11356 /* pre-order tranversal, check itself first */
11357 level = btrfs_header_level(node);
11358 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11359 btrfs_header_level(node),
11360 btrfs_header_owner(node));
11364 "check %s failed root %llu bytenr %llu level %d, force continue check",
11365 level ? "node":"leaf", root->objectid,
11366 btrfs_header_bytenr(node), btrfs_header_level(node));
11369 btree_space_waste += btrfs_leaf_free_space(root, node);
11370 ret = check_leaf_items(root, node);
11375 nr = btrfs_header_nritems(node);
11376 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11377 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11378 sizeof(struct btrfs_key_ptr);
11380 /* Then check all its children */
11381 for (i = 0; i < nr; i++) {
11382 u64 blocknr = btrfs_node_blockptr(node, i);
11384 btrfs_node_key_to_cpu(node, &key, i);
11385 if (level == root->root_item.drop_level &&
11386 is_dropped_key(&key, &drop_key))
11390 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11391 * to call the function itself.
11393 eb = read_tree_block(root, blocknr, root->nodesize, 0);
11394 if (extent_buffer_uptodate(eb)) {
11395 ret = traverse_tree_block(root, eb);
11398 free_extent_buffer(eb);
11405 * Low memory usage version check_chunks_and_extents.
11407 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11409 struct btrfs_path path;
11410 struct btrfs_key key;
11411 struct btrfs_root *root1;
11412 struct btrfs_root *cur_root;
11416 root1 = root->fs_info->chunk_root;
11417 ret = traverse_tree_block(root1, root1->node);
11420 root1 = root->fs_info->tree_root;
11421 ret = traverse_tree_block(root1, root1->node);
11424 btrfs_init_path(&path);
11425 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11427 key.type = BTRFS_ROOT_ITEM_KEY;
11429 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11431 error("cannot find extent treet in tree_root");
11436 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11437 if (key.type != BTRFS_ROOT_ITEM_KEY)
11439 key.offset = (u64)-1;
11441 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11442 cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
11445 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11446 if (IS_ERR(cur_root) || !cur_root) {
11447 error("failed to read tree: %lld", key.objectid);
11451 ret = traverse_tree_block(cur_root, cur_root->node);
11454 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11455 btrfs_free_fs_root(cur_root);
11457 ret = btrfs_next_item(root1, &path);
11463 btrfs_release_path(&path);
11467 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11468 struct btrfs_root *root, int overwrite)
11470 struct extent_buffer *c;
11471 struct extent_buffer *old = root->node;
11474 struct btrfs_disk_key disk_key = {0,0,0};
11480 extent_buffer_get(c);
11483 c = btrfs_alloc_free_block(trans, root,
11485 root->root_key.objectid,
11486 &disk_key, level, 0, 0);
11489 extent_buffer_get(c);
11493 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11494 btrfs_set_header_level(c, level);
11495 btrfs_set_header_bytenr(c, c->start);
11496 btrfs_set_header_generation(c, trans->transid);
11497 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11498 btrfs_set_header_owner(c, root->root_key.objectid);
11500 write_extent_buffer(c, root->fs_info->fsid,
11501 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11503 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11504 btrfs_header_chunk_tree_uuid(c),
11507 btrfs_mark_buffer_dirty(c);
11509 * this case can happen in the following case:
11511 * 1.overwrite previous root.
11513 * 2.reinit reloc data root, this is because we skip pin
11514 * down reloc data tree before which means we can allocate
11515 * same block bytenr here.
11517 if (old->start == c->start) {
11518 btrfs_set_root_generation(&root->root_item,
11520 root->root_item.level = btrfs_header_level(root->node);
11521 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11522 &root->root_key, &root->root_item);
11524 free_extent_buffer(c);
11528 free_extent_buffer(old);
11530 add_root_to_dirty_list(root);
11534 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11535 struct extent_buffer *eb, int tree_root)
11537 struct extent_buffer *tmp;
11538 struct btrfs_root_item *ri;
11539 struct btrfs_key key;
11542 int level = btrfs_header_level(eb);
11548 * If we have pinned this block before, don't pin it again.
11549 * This can not only avoid forever loop with broken filesystem
11550 * but also give us some speedups.
11552 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11553 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11556 btrfs_pin_extent(fs_info, eb->start, eb->len);
11558 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11559 nritems = btrfs_header_nritems(eb);
11560 for (i = 0; i < nritems; i++) {
11562 btrfs_item_key_to_cpu(eb, &key, i);
11563 if (key.type != BTRFS_ROOT_ITEM_KEY)
11565 /* Skip the extent root and reloc roots */
11566 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11567 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11568 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11570 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11571 bytenr = btrfs_disk_root_bytenr(eb, ri);
11574 * If at any point we start needing the real root we
11575 * will have to build a stump root for the root we are
11576 * in, but for now this doesn't actually use the root so
11577 * just pass in extent_root.
11579 tmp = read_tree_block(fs_info->extent_root, bytenr,
11581 if (!extent_buffer_uptodate(tmp)) {
11582 fprintf(stderr, "Error reading root block\n");
11585 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11586 free_extent_buffer(tmp);
11590 bytenr = btrfs_node_blockptr(eb, i);
11592 /* If we aren't the tree root don't read the block */
11593 if (level == 1 && !tree_root) {
11594 btrfs_pin_extent(fs_info, bytenr, nodesize);
11598 tmp = read_tree_block(fs_info->extent_root, bytenr,
11600 if (!extent_buffer_uptodate(tmp)) {
11601 fprintf(stderr, "Error reading tree block\n");
11604 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11605 free_extent_buffer(tmp);
11614 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11618 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11622 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11625 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11627 struct btrfs_block_group_cache *cache;
11628 struct btrfs_path path;
11629 struct extent_buffer *leaf;
11630 struct btrfs_chunk *chunk;
11631 struct btrfs_key key;
11635 btrfs_init_path(&path);
11637 key.type = BTRFS_CHUNK_ITEM_KEY;
11639 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11641 btrfs_release_path(&path);
11646 * We do this in case the block groups were screwed up and had alloc
11647 * bits that aren't actually set on the chunks. This happens with
11648 * restored images every time and could happen in real life I guess.
11650 fs_info->avail_data_alloc_bits = 0;
11651 fs_info->avail_metadata_alloc_bits = 0;
11652 fs_info->avail_system_alloc_bits = 0;
11654 /* First we need to create the in-memory block groups */
11656 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11657 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11659 btrfs_release_path(&path);
11667 leaf = path.nodes[0];
11668 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11669 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11674 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11675 btrfs_add_block_group(fs_info, 0,
11676 btrfs_chunk_type(leaf, chunk),
11677 key.objectid, key.offset,
11678 btrfs_chunk_length(leaf, chunk));
11679 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11680 key.offset + btrfs_chunk_length(leaf, chunk),
11686 cache = btrfs_lookup_first_block_group(fs_info, start);
11690 start = cache->key.objectid + cache->key.offset;
11693 btrfs_release_path(&path);
11697 static int reset_balance(struct btrfs_trans_handle *trans,
11698 struct btrfs_fs_info *fs_info)
11700 struct btrfs_root *root = fs_info->tree_root;
11701 struct btrfs_path path;
11702 struct extent_buffer *leaf;
11703 struct btrfs_key key;
11704 int del_slot, del_nr = 0;
11708 btrfs_init_path(&path);
11709 key.objectid = BTRFS_BALANCE_OBJECTID;
11710 key.type = BTRFS_BALANCE_ITEM_KEY;
11712 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11717 goto reinit_data_reloc;
11722 ret = btrfs_del_item(trans, root, &path);
11725 btrfs_release_path(&path);
11727 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11728 key.type = BTRFS_ROOT_ITEM_KEY;
11730 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11734 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11739 ret = btrfs_del_items(trans, root, &path,
11746 btrfs_release_path(&path);
11749 ret = btrfs_search_slot(trans, root, &key, &path,
11756 leaf = path.nodes[0];
11757 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11758 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11760 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11765 del_slot = path.slots[0];
11774 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11778 btrfs_release_path(&path);
11781 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11782 key.type = BTRFS_ROOT_ITEM_KEY;
11783 key.offset = (u64)-1;
11784 root = btrfs_read_fs_root(fs_info, &key);
11785 if (IS_ERR(root)) {
11786 fprintf(stderr, "Error reading data reloc tree\n");
11787 ret = PTR_ERR(root);
11790 record_root_in_trans(trans, root);
11791 ret = btrfs_fsck_reinit_root(trans, root, 0);
11794 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11796 btrfs_release_path(&path);
11800 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11801 struct btrfs_fs_info *fs_info)
11807 * The only reason we don't do this is because right now we're just
11808 * walking the trees we find and pinning down their bytes, we don't look
11809 * at any of the leaves. In order to do mixed groups we'd have to check
11810 * the leaves of any fs roots and pin down the bytes for any file
11811 * extents we find. Not hard but why do it if we don't have to?
11813 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11814 fprintf(stderr, "We don't support re-initing the extent tree "
11815 "for mixed block groups yet, please notify a btrfs "
11816 "developer you want to do this so they can add this "
11817 "functionality.\n");
11822 * first we need to walk all of the trees except the extent tree and pin
11823 * down the bytes that are in use so we don't overwrite any existing
11826 ret = pin_metadata_blocks(fs_info);
11828 fprintf(stderr, "error pinning down used bytes\n");
11833 * Need to drop all the block groups since we're going to recreate all
11836 btrfs_free_block_groups(fs_info);
11837 ret = reset_block_groups(fs_info);
11839 fprintf(stderr, "error resetting the block groups\n");
11843 /* Ok we can allocate now, reinit the extent root */
11844 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11846 fprintf(stderr, "extent root initialization failed\n");
11848 * When the transaction code is updated we should end the
11849 * transaction, but for now progs only knows about commit so
11850 * just return an error.
11856 * Now we have all the in-memory block groups setup so we can make
11857 * allocations properly, and the metadata we care about is safe since we
11858 * pinned all of it above.
11861 struct btrfs_block_group_cache *cache;
11863 cache = btrfs_lookup_first_block_group(fs_info, start);
11866 start = cache->key.objectid + cache->key.offset;
11867 ret = btrfs_insert_item(trans, fs_info->extent_root,
11868 &cache->key, &cache->item,
11869 sizeof(cache->item));
11871 fprintf(stderr, "Error adding block group\n");
11874 btrfs_extent_post_op(trans, fs_info->extent_root);
11877 ret = reset_balance(trans, fs_info);
11879 fprintf(stderr, "error resetting the pending balance\n");
11884 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
11886 struct btrfs_path path;
11887 struct btrfs_trans_handle *trans;
11888 struct btrfs_key key;
11891 printf("Recowing metadata block %llu\n", eb->start);
11892 key.objectid = btrfs_header_owner(eb);
11893 key.type = BTRFS_ROOT_ITEM_KEY;
11894 key.offset = (u64)-1;
11896 root = btrfs_read_fs_root(root->fs_info, &key);
11897 if (IS_ERR(root)) {
11898 fprintf(stderr, "Couldn't find owner root %llu\n",
11900 return PTR_ERR(root);
11903 trans = btrfs_start_transaction(root, 1);
11905 return PTR_ERR(trans);
11907 btrfs_init_path(&path);
11908 path.lowest_level = btrfs_header_level(eb);
11909 if (path.lowest_level)
11910 btrfs_node_key_to_cpu(eb, &key, 0);
11912 btrfs_item_key_to_cpu(eb, &key, 0);
11914 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
11915 btrfs_commit_transaction(trans, root);
11916 btrfs_release_path(&path);
11920 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
11922 struct btrfs_path path;
11923 struct btrfs_trans_handle *trans;
11924 struct btrfs_key key;
11927 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
11928 bad->key.type, bad->key.offset);
11929 key.objectid = bad->root_id;
11930 key.type = BTRFS_ROOT_ITEM_KEY;
11931 key.offset = (u64)-1;
11933 root = btrfs_read_fs_root(root->fs_info, &key);
11934 if (IS_ERR(root)) {
11935 fprintf(stderr, "Couldn't find owner root %llu\n",
11937 return PTR_ERR(root);
11940 trans = btrfs_start_transaction(root, 1);
11942 return PTR_ERR(trans);
11944 btrfs_init_path(&path);
11945 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
11951 ret = btrfs_del_item(trans, root, &path);
11953 btrfs_commit_transaction(trans, root);
11954 btrfs_release_path(&path);
11958 static int zero_log_tree(struct btrfs_root *root)
11960 struct btrfs_trans_handle *trans;
11963 trans = btrfs_start_transaction(root, 1);
11964 if (IS_ERR(trans)) {
11965 ret = PTR_ERR(trans);
11968 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
11969 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
11970 ret = btrfs_commit_transaction(trans, root);
11974 static int populate_csum(struct btrfs_trans_handle *trans,
11975 struct btrfs_root *csum_root, char *buf, u64 start,
11982 while (offset < len) {
11983 sectorsize = csum_root->sectorsize;
11984 ret = read_extent_data(csum_root, buf, start + offset,
11988 ret = btrfs_csum_file_block(trans, csum_root, start + len,
11989 start + offset, buf, sectorsize);
11992 offset += sectorsize;
11997 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
11998 struct btrfs_root *csum_root,
11999 struct btrfs_root *cur_root)
12001 struct btrfs_path path;
12002 struct btrfs_key key;
12003 struct extent_buffer *node;
12004 struct btrfs_file_extent_item *fi;
12011 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
12015 btrfs_init_path(&path);
12019 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
12022 /* Iterate all regular file extents and fill its csum */
12024 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12026 if (key.type != BTRFS_EXTENT_DATA_KEY)
12028 node = path.nodes[0];
12029 slot = path.slots[0];
12030 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
12031 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
12033 start = btrfs_file_extent_disk_bytenr(node, fi);
12034 len = btrfs_file_extent_disk_num_bytes(node, fi);
12036 ret = populate_csum(trans, csum_root, buf, start, len);
12037 if (ret == -EEXIST)
12043 * TODO: if next leaf is corrupted, jump to nearest next valid
12046 ret = btrfs_next_item(cur_root, &path);
12056 btrfs_release_path(&path);
12061 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12062 struct btrfs_root *csum_root)
12064 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12065 struct btrfs_path path;
12066 struct btrfs_root *tree_root = fs_info->tree_root;
12067 struct btrfs_root *cur_root;
12068 struct extent_buffer *node;
12069 struct btrfs_key key;
12073 btrfs_init_path(&path);
12074 key.objectid = BTRFS_FS_TREE_OBJECTID;
12076 key.type = BTRFS_ROOT_ITEM_KEY;
12077 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12086 node = path.nodes[0];
12087 slot = path.slots[0];
12088 btrfs_item_key_to_cpu(node, &key, slot);
12089 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12091 if (key.type != BTRFS_ROOT_ITEM_KEY)
12093 if (!is_fstree(key.objectid))
12095 key.offset = (u64)-1;
12097 cur_root = btrfs_read_fs_root(fs_info, &key);
12098 if (IS_ERR(cur_root) || !cur_root) {
12099 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12103 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12108 ret = btrfs_next_item(tree_root, &path);
12118 btrfs_release_path(&path);
12122 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12123 struct btrfs_root *csum_root)
12125 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12126 struct btrfs_path path;
12127 struct btrfs_extent_item *ei;
12128 struct extent_buffer *leaf;
12130 struct btrfs_key key;
12133 btrfs_init_path(&path);
12135 key.type = BTRFS_EXTENT_ITEM_KEY;
12137 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12139 btrfs_release_path(&path);
12143 buf = malloc(csum_root->sectorsize);
12145 btrfs_release_path(&path);
12150 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12151 ret = btrfs_next_leaf(extent_root, &path);
12159 leaf = path.nodes[0];
12161 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12162 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12167 ei = btrfs_item_ptr(leaf, path.slots[0],
12168 struct btrfs_extent_item);
12169 if (!(btrfs_extent_flags(leaf, ei) &
12170 BTRFS_EXTENT_FLAG_DATA)) {
12175 ret = populate_csum(trans, csum_root, buf, key.objectid,
12182 btrfs_release_path(&path);
12188 * Recalculate the csum and put it into the csum tree.
12190 * Extent tree init will wipe out all the extent info, so in that case, we
12191 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12192 * will use fs/subvol trees to init the csum tree.
12194 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12195 struct btrfs_root *csum_root,
12196 int search_fs_tree)
12198 if (search_fs_tree)
12199 return fill_csum_tree_from_fs(trans, csum_root);
12201 return fill_csum_tree_from_extent(trans, csum_root);
12204 static void free_roots_info_cache(void)
12206 if (!roots_info_cache)
12209 while (!cache_tree_empty(roots_info_cache)) {
12210 struct cache_extent *entry;
12211 struct root_item_info *rii;
12213 entry = first_cache_extent(roots_info_cache);
12216 remove_cache_extent(roots_info_cache, entry);
12217 rii = container_of(entry, struct root_item_info, cache_extent);
12221 free(roots_info_cache);
12222 roots_info_cache = NULL;
12225 static int build_roots_info_cache(struct btrfs_fs_info *info)
12228 struct btrfs_key key;
12229 struct extent_buffer *leaf;
12230 struct btrfs_path path;
12232 if (!roots_info_cache) {
12233 roots_info_cache = malloc(sizeof(*roots_info_cache));
12234 if (!roots_info_cache)
12236 cache_tree_init(roots_info_cache);
12239 btrfs_init_path(&path);
12241 key.type = BTRFS_EXTENT_ITEM_KEY;
12243 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12246 leaf = path.nodes[0];
12249 struct btrfs_key found_key;
12250 struct btrfs_extent_item *ei;
12251 struct btrfs_extent_inline_ref *iref;
12252 int slot = path.slots[0];
12257 struct cache_extent *entry;
12258 struct root_item_info *rii;
12260 if (slot >= btrfs_header_nritems(leaf)) {
12261 ret = btrfs_next_leaf(info->extent_root, &path);
12268 leaf = path.nodes[0];
12269 slot = path.slots[0];
12272 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12274 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12275 found_key.type != BTRFS_METADATA_ITEM_KEY)
12278 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12279 flags = btrfs_extent_flags(leaf, ei);
12281 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12282 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12285 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12286 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12287 level = found_key.offset;
12289 struct btrfs_tree_block_info *binfo;
12291 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12292 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12293 level = btrfs_tree_block_level(leaf, binfo);
12297 * For a root extent, it must be of the following type and the
12298 * first (and only one) iref in the item.
12300 type = btrfs_extent_inline_ref_type(leaf, iref);
12301 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12304 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12305 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12307 rii = malloc(sizeof(struct root_item_info));
12312 rii->cache_extent.start = root_id;
12313 rii->cache_extent.size = 1;
12314 rii->level = (u8)-1;
12315 entry = &rii->cache_extent;
12316 ret = insert_cache_extent(roots_info_cache, entry);
12319 rii = container_of(entry, struct root_item_info,
12323 ASSERT(rii->cache_extent.start == root_id);
12324 ASSERT(rii->cache_extent.size == 1);
12326 if (level > rii->level || rii->level == (u8)-1) {
12327 rii->level = level;
12328 rii->bytenr = found_key.objectid;
12329 rii->gen = btrfs_extent_generation(leaf, ei);
12330 rii->node_count = 1;
12331 } else if (level == rii->level) {
12339 btrfs_release_path(&path);
12344 static int maybe_repair_root_item(struct btrfs_fs_info *info,
12345 struct btrfs_path *path,
12346 const struct btrfs_key *root_key,
12347 const int read_only_mode)
12349 const u64 root_id = root_key->objectid;
12350 struct cache_extent *entry;
12351 struct root_item_info *rii;
12352 struct btrfs_root_item ri;
12353 unsigned long offset;
12355 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12358 "Error: could not find extent items for root %llu\n",
12359 root_key->objectid);
12363 rii = container_of(entry, struct root_item_info, cache_extent);
12364 ASSERT(rii->cache_extent.start == root_id);
12365 ASSERT(rii->cache_extent.size == 1);
12367 if (rii->node_count != 1) {
12369 "Error: could not find btree root extent for root %llu\n",
12374 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12375 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12377 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12378 btrfs_root_level(&ri) != rii->level ||
12379 btrfs_root_generation(&ri) != rii->gen) {
12382 * If we're in repair mode but our caller told us to not update
12383 * the root item, i.e. just check if it needs to be updated, don't
12384 * print this message, since the caller will call us again shortly
12385 * for the same root item without read only mode (the caller will
12386 * open a transaction first).
12388 if (!(read_only_mode && repair))
12390 "%sroot item for root %llu,"
12391 " current bytenr %llu, current gen %llu, current level %u,"
12392 " new bytenr %llu, new gen %llu, new level %u\n",
12393 (read_only_mode ? "" : "fixing "),
12395 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12396 btrfs_root_level(&ri),
12397 rii->bytenr, rii->gen, rii->level);
12399 if (btrfs_root_generation(&ri) > rii->gen) {
12401 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12402 root_id, btrfs_root_generation(&ri), rii->gen);
12406 if (!read_only_mode) {
12407 btrfs_set_root_bytenr(&ri, rii->bytenr);
12408 btrfs_set_root_level(&ri, rii->level);
12409 btrfs_set_root_generation(&ri, rii->gen);
12410 write_extent_buffer(path->nodes[0], &ri,
12411 offset, sizeof(ri));
12421 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12422 * caused read-only snapshots to be corrupted if they were created at a moment
12423 * when the source subvolume/snapshot had orphan items. The issue was that the
12424 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12425 * node instead of the post orphan cleanup root node.
12426 * So this function, and its callees, just detects and fixes those cases. Even
12427 * though the regression was for read-only snapshots, this function applies to
12428 * any snapshot/subvolume root.
12429 * This must be run before any other repair code - not doing it so, makes other
12430 * repair code delete or modify backrefs in the extent tree for example, which
12431 * will result in an inconsistent fs after repairing the root items.
12433 static int repair_root_items(struct btrfs_fs_info *info)
12435 struct btrfs_path path;
12436 struct btrfs_key key;
12437 struct extent_buffer *leaf;
12438 struct btrfs_trans_handle *trans = NULL;
12441 int need_trans = 0;
12443 btrfs_init_path(&path);
12445 ret = build_roots_info_cache(info);
12449 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12450 key.type = BTRFS_ROOT_ITEM_KEY;
12455 * Avoid opening and committing transactions if a leaf doesn't have
12456 * any root items that need to be fixed, so that we avoid rotating
12457 * backup roots unnecessarily.
12460 trans = btrfs_start_transaction(info->tree_root, 1);
12461 if (IS_ERR(trans)) {
12462 ret = PTR_ERR(trans);
12467 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12471 leaf = path.nodes[0];
12474 struct btrfs_key found_key;
12476 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12477 int no_more_keys = find_next_key(&path, &key);
12479 btrfs_release_path(&path);
12481 ret = btrfs_commit_transaction(trans,
12493 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12495 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12497 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12500 ret = maybe_repair_root_item(info, &path, &found_key,
12505 if (!trans && repair) {
12508 btrfs_release_path(&path);
12518 free_roots_info_cache();
12519 btrfs_release_path(&path);
12521 btrfs_commit_transaction(trans, info->tree_root);
12528 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12530 struct btrfs_trans_handle *trans;
12531 struct btrfs_block_group_cache *bg_cache;
12535 /* Clear all free space cache inodes and its extent data */
12537 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12540 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12543 current = bg_cache->key.objectid + bg_cache->key.offset;
12546 /* Don't forget to set cache_generation to -1 */
12547 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12548 if (IS_ERR(trans)) {
12549 error("failed to update super block cache generation");
12550 return PTR_ERR(trans);
12552 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12553 btrfs_commit_transaction(trans, fs_info->tree_root);
12558 const char * const cmd_check_usage[] = {
12559 "btrfs check [options] <device>",
12560 "Check structural integrity of a filesystem (unmounted).",
12561 "Check structural integrity of an unmounted filesystem. Verify internal",
12562 "trees' consistency and item connectivity. In the repair mode try to",
12563 "fix the problems found. ",
12564 "WARNING: the repair mode is considered dangerous",
12566 "-s|--super <superblock> use this superblock copy",
12567 "-b|--backup use the first valid backup root copy",
12568 "--repair try to repair the filesystem",
12569 "--readonly run in read-only mode (default)",
12570 "--init-csum-tree create a new CRC tree",
12571 "--init-extent-tree create a new extent tree",
12572 "--mode <MODE> allows choice of memory/IO trade-offs",
12573 " where MODE is one of:",
12574 " original - read inodes and extents to memory (requires",
12575 " more memory, does less IO)",
12576 " lowmem - try to use less memory but read blocks again",
12578 "--check-data-csum verify checksums of data blocks",
12579 "-Q|--qgroup-report print a report on qgroup consistency",
12580 "-E|--subvol-extents <subvolid>",
12581 " print subvolume extents and sharing state",
12582 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12583 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12584 "-p|--progress indicate progress",
12585 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12589 int cmd_check(int argc, char **argv)
12591 struct cache_tree root_cache;
12592 struct btrfs_root *root;
12593 struct btrfs_fs_info *info;
12596 u64 tree_root_bytenr = 0;
12597 u64 chunk_root_bytenr = 0;
12598 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12602 int init_csum_tree = 0;
12604 int clear_space_cache = 0;
12605 int qgroup_report = 0;
12606 int qgroups_repaired = 0;
12607 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12611 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12612 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12613 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12614 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12615 static const struct option long_options[] = {
12616 { "super", required_argument, NULL, 's' },
12617 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12618 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12619 { "init-csum-tree", no_argument, NULL,
12620 GETOPT_VAL_INIT_CSUM },
12621 { "init-extent-tree", no_argument, NULL,
12622 GETOPT_VAL_INIT_EXTENT },
12623 { "check-data-csum", no_argument, NULL,
12624 GETOPT_VAL_CHECK_CSUM },
12625 { "backup", no_argument, NULL, 'b' },
12626 { "subvol-extents", required_argument, NULL, 'E' },
12627 { "qgroup-report", no_argument, NULL, 'Q' },
12628 { "tree-root", required_argument, NULL, 'r' },
12629 { "chunk-root", required_argument, NULL,
12630 GETOPT_VAL_CHUNK_TREE },
12631 { "progress", no_argument, NULL, 'p' },
12632 { "mode", required_argument, NULL,
12634 { "clear-space-cache", required_argument, NULL,
12635 GETOPT_VAL_CLEAR_SPACE_CACHE},
12636 { NULL, 0, NULL, 0}
12639 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
12643 case 'a': /* ignored */ break;
12645 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12648 num = arg_strtou64(optarg);
12649 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12651 "super mirror should be less than %d",
12652 BTRFS_SUPER_MIRROR_MAX);
12655 bytenr = btrfs_sb_offset(((int)num));
12656 printf("using SB copy %llu, bytenr %llu\n", num,
12657 (unsigned long long)bytenr);
12663 subvolid = arg_strtou64(optarg);
12666 tree_root_bytenr = arg_strtou64(optarg);
12668 case GETOPT_VAL_CHUNK_TREE:
12669 chunk_root_bytenr = arg_strtou64(optarg);
12672 ctx.progress_enabled = true;
12676 usage(cmd_check_usage);
12677 case GETOPT_VAL_REPAIR:
12678 printf("enabling repair mode\n");
12680 ctree_flags |= OPEN_CTREE_WRITES;
12682 case GETOPT_VAL_READONLY:
12685 case GETOPT_VAL_INIT_CSUM:
12686 printf("Creating a new CRC tree\n");
12687 init_csum_tree = 1;
12689 ctree_flags |= OPEN_CTREE_WRITES;
12691 case GETOPT_VAL_INIT_EXTENT:
12692 init_extent_tree = 1;
12693 ctree_flags |= (OPEN_CTREE_WRITES |
12694 OPEN_CTREE_NO_BLOCK_GROUPS);
12697 case GETOPT_VAL_CHECK_CSUM:
12698 check_data_csum = 1;
12700 case GETOPT_VAL_MODE:
12701 check_mode = parse_check_mode(optarg);
12702 if (check_mode == CHECK_MODE_UNKNOWN) {
12703 error("unknown mode: %s", optarg);
12707 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12708 if (strcmp(optarg, "v1") == 0) {
12709 clear_space_cache = 1;
12710 } else if (strcmp(optarg, "v2") == 0) {
12711 clear_space_cache = 2;
12712 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12715 "invalid argument to --clear-space-cache, must be v1 or v2");
12718 ctree_flags |= OPEN_CTREE_WRITES;
12723 if (check_argc_exact(argc - optind, 1))
12724 usage(cmd_check_usage);
12726 if (ctx.progress_enabled) {
12727 ctx.tp = TASK_NOTHING;
12728 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12731 /* This check is the only reason for --readonly to exist */
12732 if (readonly && repair) {
12733 error("repair options are not compatible with --readonly");
12738 * Not supported yet
12740 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12741 error("low memory mode doesn't support repair yet");
12746 cache_tree_init(&root_cache);
12748 if((ret = check_mounted(argv[optind])) < 0) {
12749 error("could not check mount status: %s", strerror(-ret));
12753 error("%s is currently mounted, aborting", argv[optind]);
12759 /* only allow partial opening under repair mode */
12761 ctree_flags |= OPEN_CTREE_PARTIAL;
12763 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12764 chunk_root_bytenr, ctree_flags);
12766 error("cannot open file system");
12772 global_info = info;
12773 root = info->fs_root;
12774 if (clear_space_cache == 1) {
12775 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12777 "free space cache v2 detected, use --clear-space-cache v2");
12781 printf("Clearing free space cache\n");
12782 ret = clear_free_space_cache(info);
12784 error("failed to clear free space cache");
12787 printf("Free space cache cleared\n");
12790 } else if (clear_space_cache == 2) {
12791 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12792 printf("no free space cache v2 to clear\n");
12796 printf("Clear free space cache v2\n");
12797 ret = btrfs_clear_free_space_tree(info);
12799 error("failed to clear free space cache v2: %d", ret);
12802 printf("free space cache v2 cleared\n");
12808 * repair mode will force us to commit transaction which
12809 * will make us fail to load log tree when mounting.
12811 if (repair && btrfs_super_log_root(info->super_copy)) {
12812 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12818 ret = zero_log_tree(root);
12821 error("failed to zero log tree: %d", ret);
12826 uuid_unparse(info->super_copy->fsid, uuidbuf);
12827 if (qgroup_report) {
12828 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12830 ret = qgroup_verify_all(info);
12837 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12838 subvolid, argv[optind], uuidbuf);
12839 ret = print_extent_state(info, subvolid);
12843 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12845 if (!extent_buffer_uptodate(info->tree_root->node) ||
12846 !extent_buffer_uptodate(info->dev_root->node) ||
12847 !extent_buffer_uptodate(info->chunk_root->node)) {
12848 error("critical roots corrupted, unable to check the filesystem");
12854 if (init_extent_tree || init_csum_tree) {
12855 struct btrfs_trans_handle *trans;
12857 trans = btrfs_start_transaction(info->extent_root, 0);
12858 if (IS_ERR(trans)) {
12859 error("error starting transaction");
12860 ret = PTR_ERR(trans);
12865 if (init_extent_tree) {
12866 printf("Creating a new extent tree\n");
12867 ret = reinit_extent_tree(trans, info);
12873 if (init_csum_tree) {
12874 printf("Reinitialize checksum tree\n");
12875 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
12877 error("checksum tree initialization failed: %d",
12884 ret = fill_csum_tree(trans, info->csum_root,
12888 error("checksum tree refilling failed: %d", ret);
12893 * Ok now we commit and run the normal fsck, which will add
12894 * extent entries for all of the items it finds.
12896 ret = btrfs_commit_transaction(trans, info->extent_root);
12901 if (!extent_buffer_uptodate(info->extent_root->node)) {
12902 error("critical: extent_root, unable to check the filesystem");
12907 if (!extent_buffer_uptodate(info->csum_root->node)) {
12908 error("critical: csum_root, unable to check the filesystem");
12914 if (!ctx.progress_enabled)
12915 fprintf(stderr, "checking extents\n");
12916 if (check_mode == CHECK_MODE_LOWMEM)
12917 ret = check_chunks_and_extents_v2(root);
12919 ret = check_chunks_and_extents(root);
12923 "errors found in extent allocation tree or chunk allocation");
12925 ret = repair_root_items(info);
12930 fprintf(stderr, "Fixed %d roots.\n", ret);
12932 } else if (ret > 0) {
12934 "Found %d roots with an outdated root item.\n",
12937 "Please run a filesystem check with the option --repair to fix them.\n");
12943 if (!ctx.progress_enabled) {
12944 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12945 fprintf(stderr, "checking free space tree\n");
12947 fprintf(stderr, "checking free space cache\n");
12949 ret = check_space_cache(root);
12955 * We used to have to have these hole extents in between our real
12956 * extents so if we don't have this flag set we need to make sure there
12957 * are no gaps in the file extents for inodes, otherwise we can just
12958 * ignore it when this happens.
12960 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
12961 if (!ctx.progress_enabled)
12962 fprintf(stderr, "checking fs roots\n");
12963 if (check_mode == CHECK_MODE_LOWMEM)
12964 ret = check_fs_roots_v2(root->fs_info);
12966 ret = check_fs_roots(root, &root_cache);
12971 fprintf(stderr, "checking csums\n");
12972 ret = check_csums(root);
12977 fprintf(stderr, "checking root refs\n");
12978 /* For low memory mode, check_fs_roots_v2 handles root refs */
12979 if (check_mode != CHECK_MODE_LOWMEM) {
12980 ret = check_root_refs(root, &root_cache);
12986 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
12987 struct extent_buffer *eb;
12989 eb = list_first_entry(&root->fs_info->recow_ebs,
12990 struct extent_buffer, recow);
12991 list_del_init(&eb->recow);
12992 ret = recow_extent_buffer(root, eb);
12998 while (!list_empty(&delete_items)) {
12999 struct bad_item *bad;
13001 bad = list_first_entry(&delete_items, struct bad_item, list);
13002 list_del_init(&bad->list);
13004 ret = delete_bad_item(root, bad);
13010 if (info->quota_enabled) {
13011 fprintf(stderr, "checking quota groups\n");
13012 ret = qgroup_verify_all(info);
13017 ret = repair_qgroups(info, &qgroups_repaired);
13024 if (!list_empty(&root->fs_info->recow_ebs)) {
13025 error("transid errors in file system");
13030 if (found_old_backref) { /*
13031 * there was a disk format change when mixed
13032 * backref was in testing tree. The old format
13033 * existed about one week.
13035 printf("\n * Found old mixed backref format. "
13036 "The old format is not supported! *"
13037 "\n * Please mount the FS in readonly mode, "
13038 "backup data and re-format the FS. *\n\n");
13041 printf("found %llu bytes used err is %d\n",
13042 (unsigned long long)bytes_used, ret);
13043 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
13044 printf("total tree bytes: %llu\n",
13045 (unsigned long long)total_btree_bytes);
13046 printf("total fs tree bytes: %llu\n",
13047 (unsigned long long)total_fs_tree_bytes);
13048 printf("total extent tree bytes: %llu\n",
13049 (unsigned long long)total_extent_tree_bytes);
13050 printf("btree space waste bytes: %llu\n",
13051 (unsigned long long)btree_space_waste);
13052 printf("file data blocks allocated: %llu\n referenced %llu\n",
13053 (unsigned long long)data_bytes_allocated,
13054 (unsigned long long)data_bytes_referenced);
13056 free_qgroup_counts();
13057 free_root_recs_tree(&root_cache);
13061 if (ctx.progress_enabled)
13062 task_deinit(ctx.info);