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"
43 #include "kernel-shared/ulist.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 extent_buffer *eb,
1482 int slot, struct btrfs_key *key,
1483 struct shared_node *active_node)
1493 struct btrfs_dir_item *di;
1494 struct inode_record *rec;
1495 struct cache_tree *root_cache;
1496 struct cache_tree *inode_cache;
1497 struct btrfs_key location;
1498 char namebuf[BTRFS_NAME_LEN];
1500 root_cache = &active_node->root_cache;
1501 inode_cache = &active_node->inode_cache;
1502 rec = active_node->current;
1503 rec->found_dir_item = 1;
1505 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1506 total = btrfs_item_size_nr(eb, slot);
1507 while (cur < total) {
1509 btrfs_dir_item_key_to_cpu(eb, di, &location);
1510 name_len = btrfs_dir_name_len(eb, di);
1511 data_len = btrfs_dir_data_len(eb, di);
1512 filetype = btrfs_dir_type(eb, di);
1514 rec->found_size += name_len;
1515 if (name_len <= BTRFS_NAME_LEN) {
1519 len = BTRFS_NAME_LEN;
1520 error = REF_ERR_NAME_TOO_LONG;
1522 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1524 if (location.type == BTRFS_INODE_ITEM_KEY) {
1525 add_inode_backref(inode_cache, location.objectid,
1526 key->objectid, key->offset, namebuf,
1527 len, filetype, key->type, error);
1528 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1529 add_inode_backref(root_cache, location.objectid,
1530 key->objectid, key->offset,
1531 namebuf, len, filetype,
1534 fprintf(stderr, "invalid location in dir item %u\n",
1536 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1537 key->objectid, key->offset, namebuf,
1538 len, filetype, key->type, error);
1541 len = sizeof(*di) + name_len + data_len;
1542 di = (struct btrfs_dir_item *)((char *)di + len);
1545 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1546 rec->errors |= I_ERR_DUP_DIR_INDEX;
1551 static int process_inode_ref(struct extent_buffer *eb,
1552 int slot, struct btrfs_key *key,
1553 struct shared_node *active_node)
1561 struct cache_tree *inode_cache;
1562 struct btrfs_inode_ref *ref;
1563 char namebuf[BTRFS_NAME_LEN];
1565 inode_cache = &active_node->inode_cache;
1567 ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1568 total = btrfs_item_size_nr(eb, slot);
1569 while (cur < total) {
1570 name_len = btrfs_inode_ref_name_len(eb, ref);
1571 index = btrfs_inode_ref_index(eb, ref);
1572 if (name_len <= BTRFS_NAME_LEN) {
1576 len = BTRFS_NAME_LEN;
1577 error = REF_ERR_NAME_TOO_LONG;
1579 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1580 add_inode_backref(inode_cache, key->objectid, key->offset,
1581 index, namebuf, len, 0, key->type, error);
1583 len = sizeof(*ref) + name_len;
1584 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1590 static int process_inode_extref(struct extent_buffer *eb,
1591 int slot, struct btrfs_key *key,
1592 struct shared_node *active_node)
1601 struct cache_tree *inode_cache;
1602 struct btrfs_inode_extref *extref;
1603 char namebuf[BTRFS_NAME_LEN];
1605 inode_cache = &active_node->inode_cache;
1607 extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1608 total = btrfs_item_size_nr(eb, slot);
1609 while (cur < total) {
1610 name_len = btrfs_inode_extref_name_len(eb, extref);
1611 index = btrfs_inode_extref_index(eb, extref);
1612 parent = btrfs_inode_extref_parent(eb, extref);
1613 if (name_len <= BTRFS_NAME_LEN) {
1617 len = BTRFS_NAME_LEN;
1618 error = REF_ERR_NAME_TOO_LONG;
1620 read_extent_buffer(eb, namebuf,
1621 (unsigned long)(extref + 1), len);
1622 add_inode_backref(inode_cache, key->objectid, parent,
1623 index, namebuf, len, 0, key->type, error);
1625 len = sizeof(*extref) + name_len;
1626 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1633 static int count_csum_range(struct btrfs_root *root, u64 start,
1634 u64 len, u64 *found)
1636 struct btrfs_key key;
1637 struct btrfs_path path;
1638 struct extent_buffer *leaf;
1643 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1645 btrfs_init_path(&path);
1647 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1649 key.type = BTRFS_EXTENT_CSUM_KEY;
1651 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1655 if (ret > 0 && path.slots[0] > 0) {
1656 leaf = path.nodes[0];
1657 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1658 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1659 key.type == BTRFS_EXTENT_CSUM_KEY)
1664 leaf = path.nodes[0];
1665 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1666 ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1671 leaf = path.nodes[0];
1674 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1675 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1676 key.type != BTRFS_EXTENT_CSUM_KEY)
1679 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1680 if (key.offset >= start + len)
1683 if (key.offset > start)
1686 size = btrfs_item_size_nr(leaf, path.slots[0]);
1687 csum_end = key.offset + (size / csum_size) * root->sectorsize;
1688 if (csum_end > start) {
1689 size = min(csum_end - start, len);
1698 btrfs_release_path(&path);
1704 static int process_file_extent(struct btrfs_root *root,
1705 struct extent_buffer *eb,
1706 int slot, struct btrfs_key *key,
1707 struct shared_node *active_node)
1709 struct inode_record *rec;
1710 struct btrfs_file_extent_item *fi;
1712 u64 disk_bytenr = 0;
1713 u64 extent_offset = 0;
1714 u64 mask = root->sectorsize - 1;
1718 rec = active_node->current;
1719 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1720 rec->found_file_extent = 1;
1722 if (rec->extent_start == (u64)-1) {
1723 rec->extent_start = key->offset;
1724 rec->extent_end = key->offset;
1727 if (rec->extent_end > key->offset)
1728 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1729 else if (rec->extent_end < key->offset) {
1730 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1731 key->offset - rec->extent_end);
1736 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1737 extent_type = btrfs_file_extent_type(eb, fi);
1739 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1740 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1742 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1743 rec->found_size += num_bytes;
1744 num_bytes = (num_bytes + mask) & ~mask;
1745 } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1746 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1747 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1748 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1749 extent_offset = btrfs_file_extent_offset(eb, fi);
1750 if (num_bytes == 0 || (num_bytes & mask))
1751 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1752 if (num_bytes + extent_offset >
1753 btrfs_file_extent_ram_bytes(eb, fi))
1754 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1755 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1756 (btrfs_file_extent_compression(eb, fi) ||
1757 btrfs_file_extent_encryption(eb, fi) ||
1758 btrfs_file_extent_other_encoding(eb, fi)))
1759 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1760 if (disk_bytenr > 0)
1761 rec->found_size += num_bytes;
1763 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1765 rec->extent_end = key->offset + num_bytes;
1768 * The data reloc tree will copy full extents into its inode and then
1769 * copy the corresponding csums. Because the extent it copied could be
1770 * a preallocated extent that hasn't been written to yet there may be no
1771 * csums to copy, ergo we won't have csums for our file extent. This is
1772 * ok so just don't bother checking csums if the inode belongs to the
1775 if (disk_bytenr > 0 &&
1776 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1778 if (btrfs_file_extent_compression(eb, fi))
1779 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1781 disk_bytenr += extent_offset;
1783 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1786 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1788 rec->found_csum_item = 1;
1789 if (found < num_bytes)
1790 rec->some_csum_missing = 1;
1791 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1793 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1799 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1800 struct walk_control *wc)
1802 struct btrfs_key key;
1806 struct cache_tree *inode_cache;
1807 struct shared_node *active_node;
1809 if (wc->root_level == wc->active_node &&
1810 btrfs_root_refs(&root->root_item) == 0)
1813 active_node = wc->nodes[wc->active_node];
1814 inode_cache = &active_node->inode_cache;
1815 nritems = btrfs_header_nritems(eb);
1816 for (i = 0; i < nritems; i++) {
1817 btrfs_item_key_to_cpu(eb, &key, i);
1819 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1821 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1824 if (active_node->current == NULL ||
1825 active_node->current->ino < key.objectid) {
1826 if (active_node->current) {
1827 active_node->current->checked = 1;
1828 maybe_free_inode_rec(inode_cache,
1829 active_node->current);
1831 active_node->current = get_inode_rec(inode_cache,
1833 BUG_ON(IS_ERR(active_node->current));
1836 case BTRFS_DIR_ITEM_KEY:
1837 case BTRFS_DIR_INDEX_KEY:
1838 ret = process_dir_item(eb, i, &key, active_node);
1840 case BTRFS_INODE_REF_KEY:
1841 ret = process_inode_ref(eb, i, &key, active_node);
1843 case BTRFS_INODE_EXTREF_KEY:
1844 ret = process_inode_extref(eb, i, &key, active_node);
1846 case BTRFS_INODE_ITEM_KEY:
1847 ret = process_inode_item(eb, i, &key, active_node);
1849 case BTRFS_EXTENT_DATA_KEY:
1850 ret = process_file_extent(root, eb, i, &key,
1861 u64 bytenr[BTRFS_MAX_LEVEL];
1862 u64 refs[BTRFS_MAX_LEVEL];
1863 int need_check[BTRFS_MAX_LEVEL];
1866 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
1867 struct node_refs *nrefs, u64 level);
1868 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1869 unsigned int ext_ref);
1871 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
1872 struct node_refs *nrefs, int *level, int ext_ref)
1874 struct extent_buffer *cur = path->nodes[0];
1875 struct btrfs_key key;
1879 int root_level = btrfs_header_level(root->node);
1881 int ret = 0; /* Final return value */
1882 int err = 0; /* Positive error bitmap */
1884 cur_bytenr = cur->start;
1886 /* skip to first inode item or the first inode number change */
1887 nritems = btrfs_header_nritems(cur);
1888 for (i = 0; i < nritems; i++) {
1889 btrfs_item_key_to_cpu(cur, &key, i);
1891 first_ino = key.objectid;
1892 if (key.type == BTRFS_INODE_ITEM_KEY ||
1893 (first_ino && first_ino != key.objectid))
1897 path->slots[0] = nritems;
1903 err |= check_inode_item(root, path, ext_ref);
1905 if (err & LAST_ITEM)
1908 /* still have inode items in thie leaf */
1909 if (cur->start == cur_bytenr)
1913 * we have switched to another leaf, above nodes may
1914 * have changed, here walk down the path, if a node
1915 * or leaf is shared, check whether we can skip this
1918 for (i = root_level; i >= 0; i--) {
1919 if (path->nodes[i]->start == nrefs->bytenr[i])
1922 ret = update_nodes_refs(root,
1923 path->nodes[i]->start,
1928 if (!nrefs->need_check[i]) {
1934 for (i = 0; i < *level; i++) {
1935 free_extent_buffer(path->nodes[i]);
1936 path->nodes[i] = NULL;
1941 * Convert any error bitmap to -EIO, as we should avoid
1942 * mixing positive and negative return value to represent
1950 static void reada_walk_down(struct btrfs_root *root,
1951 struct extent_buffer *node, int slot)
1960 level = btrfs_header_level(node);
1964 nritems = btrfs_header_nritems(node);
1965 blocksize = root->nodesize;
1966 for (i = slot; i < nritems; i++) {
1967 bytenr = btrfs_node_blockptr(node, i);
1968 ptr_gen = btrfs_node_ptr_generation(node, i);
1969 readahead_tree_block(root, bytenr, blocksize, ptr_gen);
1974 * Check the child node/leaf by the following condition:
1975 * 1. the first item key of the node/leaf should be the same with the one
1977 * 2. block in parent node should match the child node/leaf.
1978 * 3. generation of parent node and child's header should be consistent.
1980 * Or the child node/leaf pointed by the key in parent is not valid.
1982 * We hope to check leaf owner too, but since subvol may share leaves,
1983 * which makes leaf owner check not so strong, key check should be
1984 * sufficient enough for that case.
1986 static int check_child_node(struct extent_buffer *parent, int slot,
1987 struct extent_buffer *child)
1989 struct btrfs_key parent_key;
1990 struct btrfs_key child_key;
1993 btrfs_node_key_to_cpu(parent, &parent_key, slot);
1994 if (btrfs_header_level(child) == 0)
1995 btrfs_item_key_to_cpu(child, &child_key, 0);
1997 btrfs_node_key_to_cpu(child, &child_key, 0);
1999 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2002 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2003 parent_key.objectid, parent_key.type, parent_key.offset,
2004 child_key.objectid, child_key.type, child_key.offset);
2006 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2008 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2009 btrfs_node_blockptr(parent, slot),
2010 btrfs_header_bytenr(child));
2012 if (btrfs_node_ptr_generation(parent, slot) !=
2013 btrfs_header_generation(child)) {
2015 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2016 btrfs_header_generation(child),
2017 btrfs_node_ptr_generation(parent, slot));
2023 * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2024 * in every fs or file tree check. Here we find its all root ids, and only check
2025 * it in the fs or file tree which has the smallest root id.
2027 static int need_check(struct btrfs_root *root, struct ulist *roots)
2029 struct rb_node *node;
2030 struct ulist_node *u;
2032 if (roots->nnodes == 1)
2035 node = rb_first(&roots->root);
2036 u = rb_entry(node, struct ulist_node, rb_node);
2038 * current root id is not smallest, we skip it and let it be checked
2039 * in the fs or file tree who hash the smallest root id.
2041 if (root->objectid != u->val)
2048 * for a tree node or leaf, we record its reference count, so later if we still
2049 * process this node or leaf, don't need to compute its reference count again.
2051 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2052 struct node_refs *nrefs, u64 level)
2056 struct ulist *roots;
2058 if (nrefs->bytenr[level] != bytenr) {
2059 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2060 level, 1, &refs, NULL);
2064 nrefs->bytenr[level] = bytenr;
2065 nrefs->refs[level] = refs;
2067 ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2072 check = need_check(root, roots);
2074 nrefs->need_check[level] = check;
2076 nrefs->need_check[level] = 1;
2083 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2084 struct walk_control *wc, int *level,
2085 struct node_refs *nrefs)
2087 enum btrfs_tree_block_status status;
2090 struct extent_buffer *next;
2091 struct extent_buffer *cur;
2096 WARN_ON(*level < 0);
2097 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2099 if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2100 refs = nrefs->refs[*level];
2103 ret = btrfs_lookup_extent_info(NULL, root,
2104 path->nodes[*level]->start,
2105 *level, 1, &refs, NULL);
2110 nrefs->bytenr[*level] = path->nodes[*level]->start;
2111 nrefs->refs[*level] = refs;
2115 ret = enter_shared_node(root, path->nodes[*level]->start,
2123 while (*level >= 0) {
2124 WARN_ON(*level < 0);
2125 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2126 cur = path->nodes[*level];
2128 if (btrfs_header_level(cur) != *level)
2131 if (path->slots[*level] >= btrfs_header_nritems(cur))
2134 ret = process_one_leaf(root, cur, wc);
2139 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2140 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2141 blocksize = root->nodesize;
2143 if (bytenr == nrefs->bytenr[*level - 1]) {
2144 refs = nrefs->refs[*level - 1];
2146 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2147 *level - 1, 1, &refs, NULL);
2151 nrefs->bytenr[*level - 1] = bytenr;
2152 nrefs->refs[*level - 1] = refs;
2157 ret = enter_shared_node(root, bytenr, refs,
2160 path->slots[*level]++;
2165 next = btrfs_find_tree_block(root, bytenr, blocksize);
2166 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2167 free_extent_buffer(next);
2168 reada_walk_down(root, cur, path->slots[*level]);
2169 next = read_tree_block(root, bytenr, blocksize,
2171 if (!extent_buffer_uptodate(next)) {
2172 struct btrfs_key node_key;
2174 btrfs_node_key_to_cpu(path->nodes[*level],
2176 path->slots[*level]);
2177 btrfs_add_corrupt_extent_record(root->fs_info,
2179 path->nodes[*level]->start,
2180 root->nodesize, *level);
2186 ret = check_child_node(cur, path->slots[*level], next);
2192 if (btrfs_is_leaf(next))
2193 status = btrfs_check_leaf(root, NULL, next);
2195 status = btrfs_check_node(root, NULL, next);
2196 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2197 free_extent_buffer(next);
2202 *level = *level - 1;
2203 free_extent_buffer(path->nodes[*level]);
2204 path->nodes[*level] = next;
2205 path->slots[*level] = 0;
2208 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2212 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2213 unsigned int ext_ref);
2215 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2216 int *level, struct node_refs *nrefs, int ext_ref)
2218 enum btrfs_tree_block_status status;
2221 struct extent_buffer *next;
2222 struct extent_buffer *cur;
2226 WARN_ON(*level < 0);
2227 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2229 ret = update_nodes_refs(root, path->nodes[*level]->start,
2234 while (*level >= 0) {
2235 WARN_ON(*level < 0);
2236 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2237 cur = path->nodes[*level];
2239 if (btrfs_header_level(cur) != *level)
2242 if (path->slots[*level] >= btrfs_header_nritems(cur))
2244 /* Don't forgot to check leaf/node validation */
2246 ret = btrfs_check_leaf(root, NULL, cur);
2247 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2251 ret = process_one_leaf_v2(root, path, nrefs,
2255 ret = btrfs_check_node(root, NULL, cur);
2256 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2261 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2262 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2263 blocksize = root->nodesize;
2265 ret = update_nodes_refs(root, bytenr, nrefs, *level - 1);
2268 if (!nrefs->need_check[*level - 1]) {
2269 path->slots[*level]++;
2273 next = btrfs_find_tree_block(root, bytenr, blocksize);
2274 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2275 free_extent_buffer(next);
2276 reada_walk_down(root, cur, path->slots[*level]);
2277 next = read_tree_block(root, bytenr, blocksize,
2279 if (!extent_buffer_uptodate(next)) {
2280 struct btrfs_key node_key;
2282 btrfs_node_key_to_cpu(path->nodes[*level],
2284 path->slots[*level]);
2285 btrfs_add_corrupt_extent_record(root->fs_info,
2287 path->nodes[*level]->start,
2288 root->nodesize, *level);
2294 ret = check_child_node(cur, path->slots[*level], next);
2298 if (btrfs_is_leaf(next))
2299 status = btrfs_check_leaf(root, NULL, next);
2301 status = btrfs_check_node(root, NULL, next);
2302 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2303 free_extent_buffer(next);
2308 *level = *level - 1;
2309 free_extent_buffer(path->nodes[*level]);
2310 path->nodes[*level] = next;
2311 path->slots[*level] = 0;
2316 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2317 struct walk_control *wc, int *level)
2320 struct extent_buffer *leaf;
2322 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2323 leaf = path->nodes[i];
2324 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2329 free_extent_buffer(path->nodes[*level]);
2330 path->nodes[*level] = NULL;
2331 BUG_ON(*level > wc->active_node);
2332 if (*level == wc->active_node)
2333 leave_shared_node(root, wc, *level);
2340 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2344 struct extent_buffer *leaf;
2346 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2347 leaf = path->nodes[i];
2348 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2353 free_extent_buffer(path->nodes[*level]);
2354 path->nodes[*level] = NULL;
2361 static int check_root_dir(struct inode_record *rec)
2363 struct inode_backref *backref;
2366 if (!rec->found_inode_item || rec->errors)
2368 if (rec->nlink != 1 || rec->found_link != 0)
2370 if (list_empty(&rec->backrefs))
2372 backref = to_inode_backref(rec->backrefs.next);
2373 if (!backref->found_inode_ref)
2375 if (backref->index != 0 || backref->namelen != 2 ||
2376 memcmp(backref->name, "..", 2))
2378 if (backref->found_dir_index || backref->found_dir_item)
2385 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2386 struct btrfs_root *root, struct btrfs_path *path,
2387 struct inode_record *rec)
2389 struct btrfs_inode_item *ei;
2390 struct btrfs_key key;
2393 key.objectid = rec->ino;
2394 key.type = BTRFS_INODE_ITEM_KEY;
2395 key.offset = (u64)-1;
2397 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2401 if (!path->slots[0]) {
2408 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2409 if (key.objectid != rec->ino) {
2414 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2415 struct btrfs_inode_item);
2416 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2417 btrfs_mark_buffer_dirty(path->nodes[0]);
2418 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2419 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2420 root->root_key.objectid);
2422 btrfs_release_path(path);
2426 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2427 struct btrfs_root *root,
2428 struct btrfs_path *path,
2429 struct inode_record *rec)
2433 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2434 btrfs_release_path(path);
2436 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2440 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2441 struct btrfs_root *root,
2442 struct btrfs_path *path,
2443 struct inode_record *rec)
2445 struct btrfs_inode_item *ei;
2446 struct btrfs_key key;
2449 key.objectid = rec->ino;
2450 key.type = BTRFS_INODE_ITEM_KEY;
2453 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2460 /* Since ret == 0, no need to check anything */
2461 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2462 struct btrfs_inode_item);
2463 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2464 btrfs_mark_buffer_dirty(path->nodes[0]);
2465 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2466 printf("reset nbytes for ino %llu root %llu\n",
2467 rec->ino, root->root_key.objectid);
2469 btrfs_release_path(path);
2473 static int add_missing_dir_index(struct btrfs_root *root,
2474 struct cache_tree *inode_cache,
2475 struct inode_record *rec,
2476 struct inode_backref *backref)
2478 struct btrfs_path path;
2479 struct btrfs_trans_handle *trans;
2480 struct btrfs_dir_item *dir_item;
2481 struct extent_buffer *leaf;
2482 struct btrfs_key key;
2483 struct btrfs_disk_key disk_key;
2484 struct inode_record *dir_rec;
2485 unsigned long name_ptr;
2486 u32 data_size = sizeof(*dir_item) + backref->namelen;
2489 trans = btrfs_start_transaction(root, 1);
2491 return PTR_ERR(trans);
2493 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2494 (unsigned long long)rec->ino);
2496 btrfs_init_path(&path);
2497 key.objectid = backref->dir;
2498 key.type = BTRFS_DIR_INDEX_KEY;
2499 key.offset = backref->index;
2500 ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
2503 leaf = path.nodes[0];
2504 dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
2506 disk_key.objectid = cpu_to_le64(rec->ino);
2507 disk_key.type = BTRFS_INODE_ITEM_KEY;
2508 disk_key.offset = 0;
2510 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2511 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2512 btrfs_set_dir_data_len(leaf, dir_item, 0);
2513 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2514 name_ptr = (unsigned long)(dir_item + 1);
2515 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2516 btrfs_mark_buffer_dirty(leaf);
2517 btrfs_release_path(&path);
2518 btrfs_commit_transaction(trans, root);
2520 backref->found_dir_index = 1;
2521 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2522 BUG_ON(IS_ERR(dir_rec));
2525 dir_rec->found_size += backref->namelen;
2526 if (dir_rec->found_size == dir_rec->isize &&
2527 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2528 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2529 if (dir_rec->found_size != dir_rec->isize)
2530 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2535 static int delete_dir_index(struct btrfs_root *root,
2536 struct inode_backref *backref)
2538 struct btrfs_trans_handle *trans;
2539 struct btrfs_dir_item *di;
2540 struct btrfs_path path;
2543 trans = btrfs_start_transaction(root, 1);
2545 return PTR_ERR(trans);
2547 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2548 (unsigned long long)backref->dir,
2549 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2550 (unsigned long long)root->objectid);
2552 btrfs_init_path(&path);
2553 di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
2554 backref->name, backref->namelen,
2555 backref->index, -1);
2558 btrfs_release_path(&path);
2559 btrfs_commit_transaction(trans, root);
2566 ret = btrfs_del_item(trans, root, &path);
2568 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
2570 btrfs_release_path(&path);
2571 btrfs_commit_transaction(trans, root);
2575 static int create_inode_item(struct btrfs_root *root,
2576 struct inode_record *rec,
2577 struct inode_backref *backref, int root_dir)
2579 struct btrfs_trans_handle *trans;
2580 struct btrfs_inode_item inode_item;
2581 time_t now = time(NULL);
2584 trans = btrfs_start_transaction(root, 1);
2585 if (IS_ERR(trans)) {
2586 ret = PTR_ERR(trans);
2590 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2591 "be incomplete, please check permissions and content after "
2592 "the fsck completes.\n", (unsigned long long)root->objectid,
2593 (unsigned long long)rec->ino);
2595 memset(&inode_item, 0, sizeof(inode_item));
2596 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2598 btrfs_set_stack_inode_nlink(&inode_item, 1);
2600 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2601 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2602 if (rec->found_dir_item) {
2603 if (rec->found_file_extent)
2604 fprintf(stderr, "root %llu inode %llu has both a dir "
2605 "item and extents, unsure if it is a dir or a "
2606 "regular file so setting it as a directory\n",
2607 (unsigned long long)root->objectid,
2608 (unsigned long long)rec->ino);
2609 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2610 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2611 } else if (!rec->found_dir_item) {
2612 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2613 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2615 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2616 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2617 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2618 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2619 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2620 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2621 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2622 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2624 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2626 btrfs_commit_transaction(trans, root);
2630 static int repair_inode_backrefs(struct btrfs_root *root,
2631 struct inode_record *rec,
2632 struct cache_tree *inode_cache,
2635 struct inode_backref *tmp, *backref;
2636 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2640 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2641 if (!delete && rec->ino == root_dirid) {
2642 if (!rec->found_inode_item) {
2643 ret = create_inode_item(root, rec, backref, 1);
2650 /* Index 0 for root dir's are special, don't mess with it */
2651 if (rec->ino == root_dirid && backref->index == 0)
2655 ((backref->found_dir_index && !backref->found_inode_ref) ||
2656 (backref->found_dir_index && backref->found_inode_ref &&
2657 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2658 ret = delete_dir_index(root, backref);
2662 list_del(&backref->list);
2666 if (!delete && !backref->found_dir_index &&
2667 backref->found_dir_item && backref->found_inode_ref) {
2668 ret = add_missing_dir_index(root, inode_cache, rec,
2673 if (backref->found_dir_item &&
2674 backref->found_dir_index &&
2675 backref->found_dir_index) {
2676 if (!backref->errors &&
2677 backref->found_inode_ref) {
2678 list_del(&backref->list);
2684 if (!delete && (!backref->found_dir_index &&
2685 !backref->found_dir_item &&
2686 backref->found_inode_ref)) {
2687 struct btrfs_trans_handle *trans;
2688 struct btrfs_key location;
2690 ret = check_dir_conflict(root, backref->name,
2696 * let nlink fixing routine to handle it,
2697 * which can do it better.
2702 location.objectid = rec->ino;
2703 location.type = BTRFS_INODE_ITEM_KEY;
2704 location.offset = 0;
2706 trans = btrfs_start_transaction(root, 1);
2707 if (IS_ERR(trans)) {
2708 ret = PTR_ERR(trans);
2711 fprintf(stderr, "adding missing dir index/item pair "
2713 (unsigned long long)rec->ino);
2714 ret = btrfs_insert_dir_item(trans, root, backref->name,
2716 backref->dir, &location,
2717 imode_to_type(rec->imode),
2720 btrfs_commit_transaction(trans, root);
2724 if (!delete && (backref->found_inode_ref &&
2725 backref->found_dir_index &&
2726 backref->found_dir_item &&
2727 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2728 !rec->found_inode_item)) {
2729 ret = create_inode_item(root, rec, backref, 0);
2736 return ret ? ret : repaired;
2740 * To determine the file type for nlink/inode_item repair
2742 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2743 * Return -ENOENT if file type is not found.
2745 static int find_file_type(struct inode_record *rec, u8 *type)
2747 struct inode_backref *backref;
2749 /* For inode item recovered case */
2750 if (rec->found_inode_item) {
2751 *type = imode_to_type(rec->imode);
2755 list_for_each_entry(backref, &rec->backrefs, list) {
2756 if (backref->found_dir_index || backref->found_dir_item) {
2757 *type = backref->filetype;
2765 * To determine the file name for nlink repair
2767 * Return 0 if file name is found, set name and namelen.
2768 * Return -ENOENT if file name is not found.
2770 static int find_file_name(struct inode_record *rec,
2771 char *name, int *namelen)
2773 struct inode_backref *backref;
2775 list_for_each_entry(backref, &rec->backrefs, list) {
2776 if (backref->found_dir_index || backref->found_dir_item ||
2777 backref->found_inode_ref) {
2778 memcpy(name, backref->name, backref->namelen);
2779 *namelen = backref->namelen;
2786 /* Reset the nlink of the inode to the correct one */
2787 static int reset_nlink(struct btrfs_trans_handle *trans,
2788 struct btrfs_root *root,
2789 struct btrfs_path *path,
2790 struct inode_record *rec)
2792 struct inode_backref *backref;
2793 struct inode_backref *tmp;
2794 struct btrfs_key key;
2795 struct btrfs_inode_item *inode_item;
2798 /* We don't believe this either, reset it and iterate backref */
2799 rec->found_link = 0;
2801 /* Remove all backref including the valid ones */
2802 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2803 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2804 backref->index, backref->name,
2805 backref->namelen, 0);
2809 /* remove invalid backref, so it won't be added back */
2810 if (!(backref->found_dir_index &&
2811 backref->found_dir_item &&
2812 backref->found_inode_ref)) {
2813 list_del(&backref->list);
2820 /* Set nlink to 0 */
2821 key.objectid = rec->ino;
2822 key.type = BTRFS_INODE_ITEM_KEY;
2824 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2831 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2832 struct btrfs_inode_item);
2833 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2834 btrfs_mark_buffer_dirty(path->nodes[0]);
2835 btrfs_release_path(path);
2838 * Add back valid inode_ref/dir_item/dir_index,
2839 * add_link() will handle the nlink inc, so new nlink must be correct
2841 list_for_each_entry(backref, &rec->backrefs, list) {
2842 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2843 backref->name, backref->namelen,
2844 backref->filetype, &backref->index, 1);
2849 btrfs_release_path(path);
2853 static int get_highest_inode(struct btrfs_trans_handle *trans,
2854 struct btrfs_root *root,
2855 struct btrfs_path *path,
2858 struct btrfs_key key, found_key;
2861 btrfs_init_path(path);
2862 key.objectid = BTRFS_LAST_FREE_OBJECTID;
2864 key.type = BTRFS_INODE_ITEM_KEY;
2865 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2867 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2868 path->slots[0] - 1);
2869 *highest_ino = found_key.objectid;
2872 if (*highest_ino >= BTRFS_LAST_FREE_OBJECTID)
2874 btrfs_release_path(path);
2878 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2879 struct btrfs_root *root,
2880 struct btrfs_path *path,
2881 struct inode_record *rec)
2883 char *dir_name = "lost+found";
2884 char namebuf[BTRFS_NAME_LEN] = {0};
2889 int name_recovered = 0;
2890 int type_recovered = 0;
2894 * Get file name and type first before these invalid inode ref
2895 * are deleted by remove_all_invalid_backref()
2897 name_recovered = !find_file_name(rec, namebuf, &namelen);
2898 type_recovered = !find_file_type(rec, &type);
2900 if (!name_recovered) {
2901 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2902 rec->ino, rec->ino);
2903 namelen = count_digits(rec->ino);
2904 sprintf(namebuf, "%llu", rec->ino);
2907 if (!type_recovered) {
2908 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2910 type = BTRFS_FT_REG_FILE;
2914 ret = reset_nlink(trans, root, path, rec);
2917 "Failed to reset nlink for inode %llu: %s\n",
2918 rec->ino, strerror(-ret));
2922 if (rec->found_link == 0) {
2923 ret = get_highest_inode(trans, root, path, &lost_found_ino);
2927 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2928 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2931 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2932 dir_name, strerror(-ret));
2935 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2936 namebuf, namelen, type, NULL, 1);
2938 * Add ".INO" suffix several times to handle case where
2939 * "FILENAME.INO" is already taken by another file.
2941 while (ret == -EEXIST) {
2943 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2945 if (namelen + count_digits(rec->ino) + 1 >
2950 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2952 namelen += count_digits(rec->ino) + 1;
2953 ret = btrfs_add_link(trans, root, rec->ino,
2954 lost_found_ino, namebuf,
2955 namelen, type, NULL, 1);
2959 "Failed to link the inode %llu to %s dir: %s\n",
2960 rec->ino, dir_name, strerror(-ret));
2964 * Just increase the found_link, don't actually add the
2965 * backref. This will make things easier and this inode
2966 * record will be freed after the repair is done.
2967 * So fsck will not report problem about this inode.
2970 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2971 namelen, namebuf, dir_name);
2973 printf("Fixed the nlink of inode %llu\n", rec->ino);
2976 * Clear the flag anyway, or we will loop forever for the same inode
2977 * as it will not be removed from the bad inode list and the dead loop
2980 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2981 btrfs_release_path(path);
2986 * Check if there is any normal(reg or prealloc) file extent for given
2988 * This is used to determine the file type when neither its dir_index/item or
2989 * inode_item exists.
2991 * This will *NOT* report error, if any error happens, just consider it does
2992 * not have any normal file extent.
2994 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
2996 struct btrfs_path path;
2997 struct btrfs_key key;
2998 struct btrfs_key found_key;
2999 struct btrfs_file_extent_item *fi;
3003 btrfs_init_path(&path);
3005 key.type = BTRFS_EXTENT_DATA_KEY;
3008 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3013 if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
3014 ret = btrfs_next_leaf(root, &path);
3021 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3023 if (found_key.objectid != ino ||
3024 found_key.type != BTRFS_EXTENT_DATA_KEY)
3026 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3027 struct btrfs_file_extent_item);
3028 type = btrfs_file_extent_type(path.nodes[0], fi);
3029 if (type != BTRFS_FILE_EXTENT_INLINE) {
3035 btrfs_release_path(&path);
3039 static u32 btrfs_type_to_imode(u8 type)
3041 static u32 imode_by_btrfs_type[] = {
3042 [BTRFS_FT_REG_FILE] = S_IFREG,
3043 [BTRFS_FT_DIR] = S_IFDIR,
3044 [BTRFS_FT_CHRDEV] = S_IFCHR,
3045 [BTRFS_FT_BLKDEV] = S_IFBLK,
3046 [BTRFS_FT_FIFO] = S_IFIFO,
3047 [BTRFS_FT_SOCK] = S_IFSOCK,
3048 [BTRFS_FT_SYMLINK] = S_IFLNK,
3051 return imode_by_btrfs_type[(type)];
3054 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3055 struct btrfs_root *root,
3056 struct btrfs_path *path,
3057 struct inode_record *rec)
3061 int type_recovered = 0;
3064 printf("Trying to rebuild inode:%llu\n", rec->ino);
3066 type_recovered = !find_file_type(rec, &filetype);
3069 * Try to determine inode type if type not found.
3071 * For found regular file extent, it must be FILE.
3072 * For found dir_item/index, it must be DIR.
3074 * For undetermined one, use FILE as fallback.
3077 * 1. If found backref(inode_index/item is already handled) to it,
3079 * Need new inode-inode ref structure to allow search for that.
3081 if (!type_recovered) {
3082 if (rec->found_file_extent &&
3083 find_normal_file_extent(root, rec->ino)) {
3085 filetype = BTRFS_FT_REG_FILE;
3086 } else if (rec->found_dir_item) {
3088 filetype = BTRFS_FT_DIR;
3089 } else if (!list_empty(&rec->orphan_extents)) {
3091 filetype = BTRFS_FT_REG_FILE;
3093 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3096 filetype = BTRFS_FT_REG_FILE;
3100 ret = btrfs_new_inode(trans, root, rec->ino,
3101 mode | btrfs_type_to_imode(filetype));
3106 * Here inode rebuild is done, we only rebuild the inode item,
3107 * don't repair the nlink(like move to lost+found).
3108 * That is the job of nlink repair.
3110 * We just fill the record and return
3112 rec->found_dir_item = 1;
3113 rec->imode = mode | btrfs_type_to_imode(filetype);
3115 rec->errors &= ~I_ERR_NO_INODE_ITEM;
3116 /* Ensure the inode_nlinks repair function will be called */
3117 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3122 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3123 struct btrfs_root *root,
3124 struct btrfs_path *path,
3125 struct inode_record *rec)
3127 struct orphan_data_extent *orphan;
3128 struct orphan_data_extent *tmp;
3131 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3133 * Check for conflicting file extents
3135 * Here we don't know whether the extents is compressed or not,
3136 * so we can only assume it not compressed nor data offset,
3137 * and use its disk_len as extent length.
3139 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3140 orphan->offset, orphan->disk_len, 0);
3141 btrfs_release_path(path);
3146 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3147 orphan->disk_bytenr, orphan->disk_len);
3148 ret = btrfs_free_extent(trans,
3149 root->fs_info->extent_root,
3150 orphan->disk_bytenr, orphan->disk_len,
3151 0, root->objectid, orphan->objectid,
3156 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3157 orphan->offset, orphan->disk_bytenr,
3158 orphan->disk_len, orphan->disk_len);
3162 /* Update file size info */
3163 rec->found_size += orphan->disk_len;
3164 if (rec->found_size == rec->nbytes)
3165 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3167 /* Update the file extent hole info too */
3168 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3172 if (RB_EMPTY_ROOT(&rec->holes))
3173 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3175 list_del(&orphan->list);
3178 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3183 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3184 struct btrfs_root *root,
3185 struct btrfs_path *path,
3186 struct inode_record *rec)
3188 struct rb_node *node;
3189 struct file_extent_hole *hole;
3193 node = rb_first(&rec->holes);
3197 hole = rb_entry(node, struct file_extent_hole, node);
3198 ret = btrfs_punch_hole(trans, root, rec->ino,
3199 hole->start, hole->len);
3202 ret = del_file_extent_hole(&rec->holes, hole->start,
3206 if (RB_EMPTY_ROOT(&rec->holes))
3207 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3208 node = rb_first(&rec->holes);
3210 /* special case for a file losing all its file extent */
3212 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3213 round_up(rec->isize, root->sectorsize));
3217 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3218 rec->ino, root->objectid);
3223 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3225 struct btrfs_trans_handle *trans;
3226 struct btrfs_path path;
3229 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3230 I_ERR_NO_ORPHAN_ITEM |
3231 I_ERR_LINK_COUNT_WRONG |
3232 I_ERR_NO_INODE_ITEM |
3233 I_ERR_FILE_EXTENT_ORPHAN |
3234 I_ERR_FILE_EXTENT_DISCOUNT|
3235 I_ERR_FILE_NBYTES_WRONG)))
3239 * For nlink repair, it may create a dir and add link, so
3240 * 2 for parent(256)'s dir_index and dir_item
3241 * 2 for lost+found dir's inode_item and inode_ref
3242 * 1 for the new inode_ref of the file
3243 * 2 for lost+found dir's dir_index and dir_item for the file
3245 trans = btrfs_start_transaction(root, 7);
3247 return PTR_ERR(trans);
3249 btrfs_init_path(&path);
3250 if (rec->errors & I_ERR_NO_INODE_ITEM)
3251 ret = repair_inode_no_item(trans, root, &path, rec);
3252 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3253 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3254 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3255 ret = repair_inode_discount_extent(trans, root, &path, rec);
3256 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3257 ret = repair_inode_isize(trans, root, &path, rec);
3258 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3259 ret = repair_inode_orphan_item(trans, root, &path, rec);
3260 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3261 ret = repair_inode_nlinks(trans, root, &path, rec);
3262 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3263 ret = repair_inode_nbytes(trans, root, &path, rec);
3264 btrfs_commit_transaction(trans, root);
3265 btrfs_release_path(&path);
3269 static int check_inode_recs(struct btrfs_root *root,
3270 struct cache_tree *inode_cache)
3272 struct cache_extent *cache;
3273 struct ptr_node *node;
3274 struct inode_record *rec;
3275 struct inode_backref *backref;
3280 u64 root_dirid = btrfs_root_dirid(&root->root_item);
3282 if (btrfs_root_refs(&root->root_item) == 0) {
3283 if (!cache_tree_empty(inode_cache))
3284 fprintf(stderr, "warning line %d\n", __LINE__);
3289 * We need to repair backrefs first because we could change some of the
3290 * errors in the inode recs.
3292 * We also need to go through and delete invalid backrefs first and then
3293 * add the correct ones second. We do this because we may get EEXIST
3294 * when adding back the correct index because we hadn't yet deleted the
3297 * For example, if we were missing a dir index then the directories
3298 * isize would be wrong, so if we fixed the isize to what we thought it
3299 * would be and then fixed the backref we'd still have a invalid fs, so
3300 * we need to add back the dir index and then check to see if the isize
3305 if (stage == 3 && !err)
3308 cache = search_cache_extent(inode_cache, 0);
3309 while (repair && cache) {
3310 node = container_of(cache, struct ptr_node, cache);
3312 cache = next_cache_extent(cache);
3314 /* Need to free everything up and rescan */
3316 remove_cache_extent(inode_cache, &node->cache);
3318 free_inode_rec(rec);
3322 if (list_empty(&rec->backrefs))
3325 ret = repair_inode_backrefs(root, rec, inode_cache,
3339 rec = get_inode_rec(inode_cache, root_dirid, 0);
3340 BUG_ON(IS_ERR(rec));
3342 ret = check_root_dir(rec);
3344 fprintf(stderr, "root %llu root dir %llu error\n",
3345 (unsigned long long)root->root_key.objectid,
3346 (unsigned long long)root_dirid);
3347 print_inode_error(root, rec);
3352 struct btrfs_trans_handle *trans;
3354 trans = btrfs_start_transaction(root, 1);
3355 if (IS_ERR(trans)) {
3356 err = PTR_ERR(trans);
3361 "root %llu missing its root dir, recreating\n",
3362 (unsigned long long)root->objectid);
3364 ret = btrfs_make_root_dir(trans, root, root_dirid);
3367 btrfs_commit_transaction(trans, root);
3371 fprintf(stderr, "root %llu root dir %llu not found\n",
3372 (unsigned long long)root->root_key.objectid,
3373 (unsigned long long)root_dirid);
3377 cache = search_cache_extent(inode_cache, 0);
3380 node = container_of(cache, struct ptr_node, cache);
3382 remove_cache_extent(inode_cache, &node->cache);
3384 if (rec->ino == root_dirid ||
3385 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3386 free_inode_rec(rec);
3390 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3391 ret = check_orphan_item(root, rec->ino);
3393 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3394 if (can_free_inode_rec(rec)) {
3395 free_inode_rec(rec);
3400 if (!rec->found_inode_item)
3401 rec->errors |= I_ERR_NO_INODE_ITEM;
3402 if (rec->found_link != rec->nlink)
3403 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3405 ret = try_repair_inode(root, rec);
3406 if (ret == 0 && can_free_inode_rec(rec)) {
3407 free_inode_rec(rec);
3413 if (!(repair && ret == 0))
3415 print_inode_error(root, rec);
3416 list_for_each_entry(backref, &rec->backrefs, list) {
3417 if (!backref->found_dir_item)
3418 backref->errors |= REF_ERR_NO_DIR_ITEM;
3419 if (!backref->found_dir_index)
3420 backref->errors |= REF_ERR_NO_DIR_INDEX;
3421 if (!backref->found_inode_ref)
3422 backref->errors |= REF_ERR_NO_INODE_REF;
3423 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3424 " namelen %u name %s filetype %d errors %x",
3425 (unsigned long long)backref->dir,
3426 (unsigned long long)backref->index,
3427 backref->namelen, backref->name,
3428 backref->filetype, backref->errors);
3429 print_ref_error(backref->errors);
3431 free_inode_rec(rec);
3433 return (error > 0) ? -1 : 0;
3436 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3439 struct cache_extent *cache;
3440 struct root_record *rec = NULL;
3443 cache = lookup_cache_extent(root_cache, objectid, 1);
3445 rec = container_of(cache, struct root_record, cache);
3447 rec = calloc(1, sizeof(*rec));
3449 return ERR_PTR(-ENOMEM);
3450 rec->objectid = objectid;
3451 INIT_LIST_HEAD(&rec->backrefs);
3452 rec->cache.start = objectid;
3453 rec->cache.size = 1;
3455 ret = insert_cache_extent(root_cache, &rec->cache);
3457 return ERR_PTR(-EEXIST);
3462 static struct root_backref *get_root_backref(struct root_record *rec,
3463 u64 ref_root, u64 dir, u64 index,
3464 const char *name, int namelen)
3466 struct root_backref *backref;
3468 list_for_each_entry(backref, &rec->backrefs, list) {
3469 if (backref->ref_root != ref_root || backref->dir != dir ||
3470 backref->namelen != namelen)
3472 if (memcmp(name, backref->name, namelen))
3477 backref = calloc(1, sizeof(*backref) + namelen + 1);
3480 backref->ref_root = ref_root;
3482 backref->index = index;
3483 backref->namelen = namelen;
3484 memcpy(backref->name, name, namelen);
3485 backref->name[namelen] = '\0';
3486 list_add_tail(&backref->list, &rec->backrefs);
3490 static void free_root_record(struct cache_extent *cache)
3492 struct root_record *rec;
3493 struct root_backref *backref;
3495 rec = container_of(cache, struct root_record, cache);
3496 while (!list_empty(&rec->backrefs)) {
3497 backref = to_root_backref(rec->backrefs.next);
3498 list_del(&backref->list);
3505 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3507 static int add_root_backref(struct cache_tree *root_cache,
3508 u64 root_id, u64 ref_root, u64 dir, u64 index,
3509 const char *name, int namelen,
3510 int item_type, int errors)
3512 struct root_record *rec;
3513 struct root_backref *backref;
3515 rec = get_root_rec(root_cache, root_id);
3516 BUG_ON(IS_ERR(rec));
3517 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3520 backref->errors |= errors;
3522 if (item_type != BTRFS_DIR_ITEM_KEY) {
3523 if (backref->found_dir_index || backref->found_back_ref ||
3524 backref->found_forward_ref) {
3525 if (backref->index != index)
3526 backref->errors |= REF_ERR_INDEX_UNMATCH;
3528 backref->index = index;
3532 if (item_type == BTRFS_DIR_ITEM_KEY) {
3533 if (backref->found_forward_ref)
3535 backref->found_dir_item = 1;
3536 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3537 backref->found_dir_index = 1;
3538 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3539 if (backref->found_forward_ref)
3540 backref->errors |= REF_ERR_DUP_ROOT_REF;
3541 else if (backref->found_dir_item)
3543 backref->found_forward_ref = 1;
3544 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3545 if (backref->found_back_ref)
3546 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3547 backref->found_back_ref = 1;
3552 if (backref->found_forward_ref && backref->found_dir_item)
3553 backref->reachable = 1;
3557 static int merge_root_recs(struct btrfs_root *root,
3558 struct cache_tree *src_cache,
3559 struct cache_tree *dst_cache)
3561 struct cache_extent *cache;
3562 struct ptr_node *node;
3563 struct inode_record *rec;
3564 struct inode_backref *backref;
3567 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3568 free_inode_recs_tree(src_cache);
3573 cache = search_cache_extent(src_cache, 0);
3576 node = container_of(cache, struct ptr_node, cache);
3578 remove_cache_extent(src_cache, &node->cache);
3581 ret = is_child_root(root, root->objectid, rec->ino);
3587 list_for_each_entry(backref, &rec->backrefs, list) {
3588 BUG_ON(backref->found_inode_ref);
3589 if (backref->found_dir_item)
3590 add_root_backref(dst_cache, rec->ino,
3591 root->root_key.objectid, backref->dir,
3592 backref->index, backref->name,
3593 backref->namelen, BTRFS_DIR_ITEM_KEY,
3595 if (backref->found_dir_index)
3596 add_root_backref(dst_cache, rec->ino,
3597 root->root_key.objectid, backref->dir,
3598 backref->index, backref->name,
3599 backref->namelen, BTRFS_DIR_INDEX_KEY,
3603 free_inode_rec(rec);
3610 static int check_root_refs(struct btrfs_root *root,
3611 struct cache_tree *root_cache)
3613 struct root_record *rec;
3614 struct root_record *ref_root;
3615 struct root_backref *backref;
3616 struct cache_extent *cache;
3622 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3623 BUG_ON(IS_ERR(rec));
3626 /* fixme: this can not detect circular references */
3629 cache = search_cache_extent(root_cache, 0);
3633 rec = container_of(cache, struct root_record, cache);
3634 cache = next_cache_extent(cache);
3636 if (rec->found_ref == 0)
3639 list_for_each_entry(backref, &rec->backrefs, list) {
3640 if (!backref->reachable)
3643 ref_root = get_root_rec(root_cache,
3645 BUG_ON(IS_ERR(ref_root));
3646 if (ref_root->found_ref > 0)
3649 backref->reachable = 0;
3651 if (rec->found_ref == 0)
3657 cache = search_cache_extent(root_cache, 0);
3661 rec = container_of(cache, struct root_record, cache);
3662 cache = next_cache_extent(cache);
3664 if (rec->found_ref == 0 &&
3665 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3666 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3667 ret = check_orphan_item(root->fs_info->tree_root,
3673 * If we don't have a root item then we likely just have
3674 * a dir item in a snapshot for this root but no actual
3675 * ref key or anything so it's meaningless.
3677 if (!rec->found_root_item)
3680 fprintf(stderr, "fs tree %llu not referenced\n",
3681 (unsigned long long)rec->objectid);
3685 if (rec->found_ref > 0 && !rec->found_root_item)
3687 list_for_each_entry(backref, &rec->backrefs, list) {
3688 if (!backref->found_dir_item)
3689 backref->errors |= REF_ERR_NO_DIR_ITEM;
3690 if (!backref->found_dir_index)
3691 backref->errors |= REF_ERR_NO_DIR_INDEX;
3692 if (!backref->found_back_ref)
3693 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3694 if (!backref->found_forward_ref)
3695 backref->errors |= REF_ERR_NO_ROOT_REF;
3696 if (backref->reachable && backref->errors)
3703 fprintf(stderr, "fs tree %llu refs %u %s\n",
3704 (unsigned long long)rec->objectid, rec->found_ref,
3705 rec->found_root_item ? "" : "not found");
3707 list_for_each_entry(backref, &rec->backrefs, list) {
3708 if (!backref->reachable)
3710 if (!backref->errors && rec->found_root_item)
3712 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3713 " index %llu namelen %u name %s errors %x\n",
3714 (unsigned long long)backref->ref_root,
3715 (unsigned long long)backref->dir,
3716 (unsigned long long)backref->index,
3717 backref->namelen, backref->name,
3719 print_ref_error(backref->errors);
3722 return errors > 0 ? 1 : 0;
3725 static int process_root_ref(struct extent_buffer *eb, int slot,
3726 struct btrfs_key *key,
3727 struct cache_tree *root_cache)
3733 struct btrfs_root_ref *ref;
3734 char namebuf[BTRFS_NAME_LEN];
3737 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3739 dirid = btrfs_root_ref_dirid(eb, ref);
3740 index = btrfs_root_ref_sequence(eb, ref);
3741 name_len = btrfs_root_ref_name_len(eb, ref);
3743 if (name_len <= BTRFS_NAME_LEN) {
3747 len = BTRFS_NAME_LEN;
3748 error = REF_ERR_NAME_TOO_LONG;
3750 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3752 if (key->type == BTRFS_ROOT_REF_KEY) {
3753 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3754 index, namebuf, len, key->type, error);
3756 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3757 index, namebuf, len, key->type, error);
3762 static void free_corrupt_block(struct cache_extent *cache)
3764 struct btrfs_corrupt_block *corrupt;
3766 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3770 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3773 * Repair the btree of the given root.
3775 * The fix is to remove the node key in corrupt_blocks cache_tree.
3776 * and rebalance the tree.
3777 * After the fix, the btree should be writeable.
3779 static int repair_btree(struct btrfs_root *root,
3780 struct cache_tree *corrupt_blocks)
3782 struct btrfs_trans_handle *trans;
3783 struct btrfs_path path;
3784 struct btrfs_corrupt_block *corrupt;
3785 struct cache_extent *cache;
3786 struct btrfs_key key;
3791 if (cache_tree_empty(corrupt_blocks))
3794 trans = btrfs_start_transaction(root, 1);
3795 if (IS_ERR(trans)) {
3796 ret = PTR_ERR(trans);
3797 fprintf(stderr, "Error starting transaction: %s\n",
3801 btrfs_init_path(&path);
3802 cache = first_cache_extent(corrupt_blocks);
3804 corrupt = container_of(cache, struct btrfs_corrupt_block,
3806 level = corrupt->level;
3807 path.lowest_level = level;
3808 key.objectid = corrupt->key.objectid;
3809 key.type = corrupt->key.type;
3810 key.offset = corrupt->key.offset;
3813 * Here we don't want to do any tree balance, since it may
3814 * cause a balance with corrupted brother leaf/node,
3815 * so ins_len set to 0 here.
3816 * Balance will be done after all corrupt node/leaf is deleted.
3818 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
3821 offset = btrfs_node_blockptr(path.nodes[level],
3824 /* Remove the ptr */
3825 ret = btrfs_del_ptr(root, &path, level, path.slots[level]);
3829 * Remove the corresponding extent
3830 * return value is not concerned.
3832 btrfs_release_path(&path);
3833 ret = btrfs_free_extent(trans, root, offset, root->nodesize,
3834 0, root->root_key.objectid,
3836 cache = next_cache_extent(cache);
3839 /* Balance the btree using btrfs_search_slot() */
3840 cache = first_cache_extent(corrupt_blocks);
3842 corrupt = container_of(cache, struct btrfs_corrupt_block,
3844 memcpy(&key, &corrupt->key, sizeof(key));
3845 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
3848 /* return will always >0 since it won't find the item */
3850 btrfs_release_path(&path);
3851 cache = next_cache_extent(cache);
3854 btrfs_commit_transaction(trans, root);
3855 btrfs_release_path(&path);
3859 static int check_fs_root(struct btrfs_root *root,
3860 struct cache_tree *root_cache,
3861 struct walk_control *wc)
3867 struct btrfs_path path;
3868 struct shared_node root_node;
3869 struct root_record *rec;
3870 struct btrfs_root_item *root_item = &root->root_item;
3871 struct cache_tree corrupt_blocks;
3872 struct orphan_data_extent *orphan;
3873 struct orphan_data_extent *tmp;
3874 enum btrfs_tree_block_status status;
3875 struct node_refs nrefs;
3878 * Reuse the corrupt_block cache tree to record corrupted tree block
3880 * Unlike the usage in extent tree check, here we do it in a per
3881 * fs/subvol tree base.
3883 cache_tree_init(&corrupt_blocks);
3884 root->fs_info->corrupt_blocks = &corrupt_blocks;
3886 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3887 rec = get_root_rec(root_cache, root->root_key.objectid);
3888 BUG_ON(IS_ERR(rec));
3889 if (btrfs_root_refs(root_item) > 0)
3890 rec->found_root_item = 1;
3893 btrfs_init_path(&path);
3894 memset(&root_node, 0, sizeof(root_node));
3895 cache_tree_init(&root_node.root_cache);
3896 cache_tree_init(&root_node.inode_cache);
3897 memset(&nrefs, 0, sizeof(nrefs));
3899 /* Move the orphan extent record to corresponding inode_record */
3900 list_for_each_entry_safe(orphan, tmp,
3901 &root->orphan_data_extents, list) {
3902 struct inode_record *inode;
3904 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3906 BUG_ON(IS_ERR(inode));
3907 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3908 list_move(&orphan->list, &inode->orphan_extents);
3911 level = btrfs_header_level(root->node);
3912 memset(wc->nodes, 0, sizeof(wc->nodes));
3913 wc->nodes[level] = &root_node;
3914 wc->active_node = level;
3915 wc->root_level = level;
3917 /* We may not have checked the root block, lets do that now */
3918 if (btrfs_is_leaf(root->node))
3919 status = btrfs_check_leaf(root, NULL, root->node);
3921 status = btrfs_check_node(root, NULL, root->node);
3922 if (status != BTRFS_TREE_BLOCK_CLEAN)
3925 if (btrfs_root_refs(root_item) > 0 ||
3926 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3927 path.nodes[level] = root->node;
3928 extent_buffer_get(root->node);
3929 path.slots[level] = 0;
3931 struct btrfs_key key;
3932 struct btrfs_disk_key found_key;
3934 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3935 level = root_item->drop_level;
3936 path.lowest_level = level;
3937 if (level > btrfs_header_level(root->node) ||
3938 level >= BTRFS_MAX_LEVEL) {
3939 error("ignoring invalid drop level: %u", level);
3942 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3945 btrfs_node_key(path.nodes[level], &found_key,
3947 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3948 sizeof(found_key)));
3952 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
3958 wret = walk_up_tree(root, &path, wc, &level);
3965 btrfs_release_path(&path);
3967 if (!cache_tree_empty(&corrupt_blocks)) {
3968 struct cache_extent *cache;
3969 struct btrfs_corrupt_block *corrupt;
3971 printf("The following tree block(s) is corrupted in tree %llu:\n",
3972 root->root_key.objectid);
3973 cache = first_cache_extent(&corrupt_blocks);
3975 corrupt = container_of(cache,
3976 struct btrfs_corrupt_block,
3978 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
3979 cache->start, corrupt->level,
3980 corrupt->key.objectid, corrupt->key.type,
3981 corrupt->key.offset);
3982 cache = next_cache_extent(cache);
3985 printf("Try to repair the btree for root %llu\n",
3986 root->root_key.objectid);
3987 ret = repair_btree(root, &corrupt_blocks);
3989 fprintf(stderr, "Failed to repair btree: %s\n",
3992 printf("Btree for root %llu is fixed\n",
3993 root->root_key.objectid);
3997 err = merge_root_recs(root, &root_node.root_cache, root_cache);
4001 if (root_node.current) {
4002 root_node.current->checked = 1;
4003 maybe_free_inode_rec(&root_node.inode_cache,
4007 err = check_inode_recs(root, &root_node.inode_cache);
4011 free_corrupt_blocks_tree(&corrupt_blocks);
4012 root->fs_info->corrupt_blocks = NULL;
4013 free_orphan_data_extents(&root->orphan_data_extents);
4017 static int fs_root_objectid(u64 objectid)
4019 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4020 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4022 return is_fstree(objectid);
4025 static int check_fs_roots(struct btrfs_root *root,
4026 struct cache_tree *root_cache)
4028 struct btrfs_path path;
4029 struct btrfs_key key;
4030 struct walk_control wc;
4031 struct extent_buffer *leaf, *tree_node;
4032 struct btrfs_root *tmp_root;
4033 struct btrfs_root *tree_root = root->fs_info->tree_root;
4037 if (ctx.progress_enabled) {
4038 ctx.tp = TASK_FS_ROOTS;
4039 task_start(ctx.info);
4043 * Just in case we made any changes to the extent tree that weren't
4044 * reflected into the free space cache yet.
4047 reset_cached_block_groups(root->fs_info);
4048 memset(&wc, 0, sizeof(wc));
4049 cache_tree_init(&wc.shared);
4050 btrfs_init_path(&path);
4055 key.type = BTRFS_ROOT_ITEM_KEY;
4056 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4061 tree_node = tree_root->node;
4063 if (tree_node != tree_root->node) {
4064 free_root_recs_tree(root_cache);
4065 btrfs_release_path(&path);
4068 leaf = path.nodes[0];
4069 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4070 ret = btrfs_next_leaf(tree_root, &path);
4076 leaf = path.nodes[0];
4078 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4079 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4080 fs_root_objectid(key.objectid)) {
4081 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4082 tmp_root = btrfs_read_fs_root_no_cache(
4083 root->fs_info, &key);
4085 key.offset = (u64)-1;
4086 tmp_root = btrfs_read_fs_root(
4087 root->fs_info, &key);
4089 if (IS_ERR(tmp_root)) {
4093 ret = check_fs_root(tmp_root, root_cache, &wc);
4094 if (ret == -EAGAIN) {
4095 free_root_recs_tree(root_cache);
4096 btrfs_release_path(&path);
4101 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4102 btrfs_free_fs_root(tmp_root);
4103 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4104 key.type == BTRFS_ROOT_BACKREF_KEY) {
4105 process_root_ref(leaf, path.slots[0], &key,
4112 btrfs_release_path(&path);
4114 free_extent_cache_tree(&wc.shared);
4115 if (!cache_tree_empty(&wc.shared))
4116 fprintf(stderr, "warning line %d\n", __LINE__);
4118 task_stop(ctx.info);
4124 * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4125 * INODE_REF/INODE_EXTREF match.
4127 * @root: the root of the fs/file tree
4128 * @ref_key: the key of the INODE_REF/INODE_EXTREF
4129 * @key: the key of the DIR_ITEM/DIR_INDEX
4130 * @index: the index in the INODE_REF/INODE_EXTREF, be used to
4131 * distinguish root_dir between normal dir/file
4132 * @name: the name in the INODE_REF/INODE_EXTREF
4133 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4134 * @mode: the st_mode of INODE_ITEM
4136 * Return 0 if no error occurred.
4137 * Return ROOT_DIR_ERROR if found DIR_ITEM/DIR_INDEX for root_dir.
4138 * Return DIR_ITEM_MISSING if couldn't find DIR_ITEM/DIR_INDEX for normal
4140 * Return DIR_ITEM_MISMATCH if INODE_REF/INODE_EXTREF and DIR_ITEM/DIR_INDEX
4141 * not match for normal dir/file.
4143 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *ref_key,
4144 struct btrfs_key *key, u64 index, char *name,
4145 u32 namelen, u32 mode)
4147 struct btrfs_path path;
4148 struct extent_buffer *node;
4149 struct btrfs_dir_item *di;
4150 struct btrfs_key location;
4151 char namebuf[BTRFS_NAME_LEN] = {0};
4161 btrfs_init_path(&path);
4162 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4164 ret = DIR_ITEM_MISSING;
4168 /* Process root dir and goto out*/
4171 ret = ROOT_DIR_ERROR;
4173 "root %llu INODE %s[%llu %llu] ROOT_DIR shouldn't have %s",
4175 ref_key->type == BTRFS_INODE_REF_KEY ?
4177 ref_key->objectid, ref_key->offset,
4178 key->type == BTRFS_DIR_ITEM_KEY ?
4179 "DIR_ITEM" : "DIR_INDEX");
4187 /* Process normal file/dir */
4189 ret = DIR_ITEM_MISSING;
4191 "root %llu INODE %s[%llu %llu] doesn't have related %s[%llu %llu] namelen %u filename %s filetype %d",
4193 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4194 ref_key->objectid, ref_key->offset,
4195 key->type == BTRFS_DIR_ITEM_KEY ?
4196 "DIR_ITEM" : "DIR_INDEX",
4197 key->objectid, key->offset, namelen, name,
4198 imode_to_type(mode));
4202 /* Check whether inode_id/filetype/name match */
4203 node = path.nodes[0];
4204 slot = path.slots[0];
4205 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4206 total = btrfs_item_size_nr(node, slot);
4207 while (cur < total) {
4208 ret = DIR_ITEM_MISMATCH;
4209 name_len = btrfs_dir_name_len(node, di);
4210 data_len = btrfs_dir_data_len(node, di);
4212 btrfs_dir_item_key_to_cpu(node, di, &location);
4213 if (location.objectid != ref_key->objectid ||
4214 location.type != BTRFS_INODE_ITEM_KEY ||
4215 location.offset != 0)
4218 filetype = btrfs_dir_type(node, di);
4219 if (imode_to_type(mode) != filetype)
4222 if (name_len <= BTRFS_NAME_LEN) {
4225 len = BTRFS_NAME_LEN;
4226 warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4228 key->type == BTRFS_DIR_ITEM_KEY ?
4229 "DIR_ITEM" : "DIR_INDEX",
4230 key->objectid, key->offset, name_len);
4232 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4233 if (len != namelen || strncmp(namebuf, name, len))
4239 len = sizeof(*di) + name_len + data_len;
4240 di = (struct btrfs_dir_item *)((char *)di + len);
4243 if (ret == DIR_ITEM_MISMATCH)
4245 "root %llu INODE %s[%llu %llu] and %s[%llu %llu] mismatch namelen %u filename %s filetype %d",
4247 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4248 ref_key->objectid, ref_key->offset,
4249 key->type == BTRFS_DIR_ITEM_KEY ?
4250 "DIR_ITEM" : "DIR_INDEX",
4251 key->objectid, key->offset, namelen, name,
4252 imode_to_type(mode));
4254 btrfs_release_path(&path);
4259 * Traverse the given INODE_REF and call find_dir_item() to find related
4260 * DIR_ITEM/DIR_INDEX.
4262 * @root: the root of the fs/file tree
4263 * @ref_key: the key of the INODE_REF
4264 * @refs: the count of INODE_REF
4265 * @mode: the st_mode of INODE_ITEM
4267 * Return 0 if no error occurred.
4269 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4270 struct extent_buffer *node, int slot, u64 *refs,
4273 struct btrfs_key key;
4274 struct btrfs_inode_ref *ref;
4275 char namebuf[BTRFS_NAME_LEN] = {0};
4283 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4284 total = btrfs_item_size_nr(node, slot);
4287 /* Update inode ref count */
4290 index = btrfs_inode_ref_index(node, ref);
4291 name_len = btrfs_inode_ref_name_len(node, ref);
4292 if (name_len <= BTRFS_NAME_LEN) {
4295 len = BTRFS_NAME_LEN;
4296 warning("root %llu INODE_REF[%llu %llu] name too long",
4297 root->objectid, ref_key->objectid, ref_key->offset);
4300 read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
4302 /* Check root dir ref name */
4303 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4304 error("root %llu INODE_REF[%llu %llu] ROOT_DIR name shouldn't be %s",
4305 root->objectid, ref_key->objectid, ref_key->offset,
4307 err |= ROOT_DIR_ERROR;
4310 /* Find related DIR_INDEX */
4311 key.objectid = ref_key->offset;
4312 key.type = BTRFS_DIR_INDEX_KEY;
4314 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4317 /* Find related dir_item */
4318 key.objectid = ref_key->offset;
4319 key.type = BTRFS_DIR_ITEM_KEY;
4320 key.offset = btrfs_name_hash(namebuf, len);
4321 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4324 len = sizeof(*ref) + name_len;
4325 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4334 * Traverse the given INODE_EXTREF and call find_dir_item() to find related
4335 * DIR_ITEM/DIR_INDEX.
4337 * @root: the root of the fs/file tree
4338 * @ref_key: the key of the INODE_EXTREF
4339 * @refs: the count of INODE_EXTREF
4340 * @mode: the st_mode of INODE_ITEM
4342 * Return 0 if no error occurred.
4344 static int check_inode_extref(struct btrfs_root *root,
4345 struct btrfs_key *ref_key,
4346 struct extent_buffer *node, int slot, u64 *refs,
4349 struct btrfs_key key;
4350 struct btrfs_inode_extref *extref;
4351 char namebuf[BTRFS_NAME_LEN] = {0};
4361 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4362 total = btrfs_item_size_nr(node, slot);
4365 /* update inode ref count */
4367 name_len = btrfs_inode_extref_name_len(node, extref);
4368 index = btrfs_inode_extref_index(node, extref);
4369 parent = btrfs_inode_extref_parent(node, extref);
4370 if (name_len <= BTRFS_NAME_LEN) {
4373 len = BTRFS_NAME_LEN;
4374 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
4375 root->objectid, ref_key->objectid, ref_key->offset);
4377 read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
4379 /* Check root dir ref name */
4380 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4381 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
4382 root->objectid, ref_key->objectid, ref_key->offset,
4384 err |= ROOT_DIR_ERROR;
4387 /* find related dir_index */
4388 key.objectid = parent;
4389 key.type = BTRFS_DIR_INDEX_KEY;
4391 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4394 /* find related dir_item */
4395 key.objectid = parent;
4396 key.type = BTRFS_DIR_ITEM_KEY;
4397 key.offset = btrfs_name_hash(namebuf, len);
4398 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4401 len = sizeof(*extref) + name_len;
4402 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4412 * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
4413 * DIR_ITEM/DIR_INDEX match.
4415 * @root: the root of the fs/file tree
4416 * @key: the key of the INODE_REF/INODE_EXTREF
4417 * @name: the name in the INODE_REF/INODE_EXTREF
4418 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4419 * @index: the index in the INODE_REF/INODE_EXTREF, for DIR_ITEM set index
4421 * @ext_ref: the EXTENDED_IREF feature
4423 * Return 0 if no error occurred.
4424 * Return >0 for error bitmap
4426 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
4427 char *name, int namelen, u64 index,
4428 unsigned int ext_ref)
4430 struct btrfs_path path;
4431 struct btrfs_inode_ref *ref;
4432 struct btrfs_inode_extref *extref;
4433 struct extent_buffer *node;
4434 char ref_namebuf[BTRFS_NAME_LEN] = {0};
4445 btrfs_init_path(&path);
4446 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4448 ret = INODE_REF_MISSING;
4452 node = path.nodes[0];
4453 slot = path.slots[0];
4455 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4456 total = btrfs_item_size_nr(node, slot);
4458 /* Iterate all entry of INODE_REF */
4459 while (cur < total) {
4460 ret = INODE_REF_MISSING;
4462 ref_namelen = btrfs_inode_ref_name_len(node, ref);
4463 ref_index = btrfs_inode_ref_index(node, ref);
4464 if (index != (u64)-1 && index != ref_index)
4467 if (ref_namelen <= BTRFS_NAME_LEN) {
4470 len = BTRFS_NAME_LEN;
4471 warning("root %llu INODE %s[%llu %llu] name too long",
4473 key->type == BTRFS_INODE_REF_KEY ?
4475 key->objectid, key->offset);
4477 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
4480 if (len != namelen || strncmp(ref_namebuf, name, len))
4486 len = sizeof(*ref) + ref_namelen;
4487 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4492 /* Skip if not support EXTENDED_IREF feature */
4496 btrfs_release_path(&path);
4497 btrfs_init_path(&path);
4499 dir_id = key->offset;
4500 key->type = BTRFS_INODE_EXTREF_KEY;
4501 key->offset = btrfs_extref_hash(dir_id, name, namelen);
4503 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4505 ret = INODE_REF_MISSING;
4509 node = path.nodes[0];
4510 slot = path.slots[0];
4512 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4514 total = btrfs_item_size_nr(node, slot);
4516 /* Iterate all entry of INODE_EXTREF */
4517 while (cur < total) {
4518 ret = INODE_REF_MISSING;
4520 ref_namelen = btrfs_inode_extref_name_len(node, extref);
4521 ref_index = btrfs_inode_extref_index(node, extref);
4522 parent = btrfs_inode_extref_parent(node, extref);
4523 if (index != (u64)-1 && index != ref_index)
4526 if (parent != dir_id)
4529 if (ref_namelen <= BTRFS_NAME_LEN) {
4532 len = BTRFS_NAME_LEN;
4533 warning("root %llu INODE %s[%llu %llu] name too long",
4535 key->type == BTRFS_INODE_REF_KEY ?
4537 key->objectid, key->offset);
4539 read_extent_buffer(node, ref_namebuf,
4540 (unsigned long)(extref + 1), len);
4542 if (len != namelen || strncmp(ref_namebuf, name, len))
4549 len = sizeof(*extref) + ref_namelen;
4550 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4555 btrfs_release_path(&path);
4560 * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
4561 * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
4563 * @root: the root of the fs/file tree
4564 * @key: the key of the INODE_REF/INODE_EXTREF
4565 * @size: the st_size of the INODE_ITEM
4566 * @ext_ref: the EXTENDED_IREF feature
4568 * Return 0 if no error occurred.
4570 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4571 struct extent_buffer *node, int slot, u64 *size,
4572 unsigned int ext_ref)
4574 struct btrfs_dir_item *di;
4575 struct btrfs_inode_item *ii;
4576 struct btrfs_path path;
4577 struct btrfs_key location;
4578 char namebuf[BTRFS_NAME_LEN] = {0};
4591 * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
4592 * ignore index check.
4594 index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
4596 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4597 total = btrfs_item_size_nr(node, slot);
4599 while (cur < total) {
4600 data_len = btrfs_dir_data_len(node, di);
4602 error("root %llu %s[%llu %llu] data_len shouldn't be %u",
4603 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4604 "DIR_ITEM" : "DIR_INDEX",
4605 key->objectid, key->offset, data_len);
4607 name_len = btrfs_dir_name_len(node, di);
4608 if (name_len <= BTRFS_NAME_LEN) {
4611 len = BTRFS_NAME_LEN;
4612 warning("root %llu %s[%llu %llu] name too long",
4614 key->type == BTRFS_DIR_ITEM_KEY ?
4615 "DIR_ITEM" : "DIR_INDEX",
4616 key->objectid, key->offset);
4618 (*size) += name_len;
4620 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4621 filetype = btrfs_dir_type(node, di);
4623 btrfs_init_path(&path);
4624 btrfs_dir_item_key_to_cpu(node, di, &location);
4626 /* Ignore related ROOT_ITEM check */
4627 if (location.type == BTRFS_ROOT_ITEM_KEY)
4630 /* Check relative INODE_ITEM(existence/filetype) */
4631 ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
4633 err |= INODE_ITEM_MISSING;
4634 error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
4635 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4636 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4637 key->offset, location.objectid, name_len,
4642 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4643 struct btrfs_inode_item);
4644 mode = btrfs_inode_mode(path.nodes[0], ii);
4646 if (imode_to_type(mode) != filetype) {
4647 err |= INODE_ITEM_MISMATCH;
4648 error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
4649 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4650 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4651 key->offset, name_len, namebuf, filetype);
4654 /* Check relative INODE_REF/INODE_EXTREF */
4655 location.type = BTRFS_INODE_REF_KEY;
4656 location.offset = key->objectid;
4657 ret = find_inode_ref(root, &location, namebuf, len,
4660 if (ret & INODE_REF_MISSING)
4661 error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
4662 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4663 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4664 key->offset, name_len, namebuf, filetype);
4667 btrfs_release_path(&path);
4668 len = sizeof(*di) + name_len + data_len;
4669 di = (struct btrfs_dir_item *)((char *)di + len);
4672 if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
4673 error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
4674 root->objectid, key->objectid, key->offset);
4683 * Check file extent datasum/hole, update the size of the file extents,
4684 * check and update the last offset of the file extent.
4686 * @root: the root of fs/file tree.
4687 * @fkey: the key of the file extent.
4688 * @nodatasum: INODE_NODATASUM feature.
4689 * @size: the sum of all EXTENT_DATA items size for this inode.
4690 * @end: the offset of the last extent.
4692 * Return 0 if no error occurred.
4694 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
4695 struct extent_buffer *node, int slot,
4696 unsigned int nodatasum, u64 *size, u64 *end)
4698 struct btrfs_file_extent_item *fi;
4701 u64 extent_num_bytes;
4703 unsigned int extent_type;
4704 unsigned int is_hole;
4708 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4710 extent_type = btrfs_file_extent_type(node, fi);
4711 /* Skip if file extent is inline */
4712 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4713 struct btrfs_item *e = btrfs_item_nr(slot);
4714 u32 item_inline_len;
4716 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4717 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4718 if (extent_num_bytes == 0 ||
4719 extent_num_bytes != item_inline_len)
4720 err |= FILE_EXTENT_ERROR;
4721 *size += extent_num_bytes;
4725 /* Check extent type */
4726 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4727 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4728 err |= FILE_EXTENT_ERROR;
4729 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4730 root->objectid, fkey->objectid, fkey->offset);
4734 /* Check REG_EXTENT/PREALLOC_EXTENT */
4735 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4736 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4737 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4738 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4740 /* Check EXTENT_DATA datasum */
4741 ret = count_csum_range(root, disk_bytenr, disk_num_bytes, &found);
4742 if (found > 0 && nodatasum) {
4743 err |= ODD_CSUM_ITEM;
4744 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4745 root->objectid, fkey->objectid, fkey->offset);
4746 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4748 (ret < 0 || found == 0 || found < disk_num_bytes)) {
4749 err |= CSUM_ITEM_MISSING;
4750 error("root %llu EXTENT_DATA[%llu %llu] datasum missing",
4751 root->objectid, fkey->objectid, fkey->offset);
4752 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && found > 0) {
4753 err |= ODD_CSUM_ITEM;
4754 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have datasum",
4755 root->objectid, fkey->objectid, fkey->offset);
4758 /* Check EXTENT_DATA hole */
4759 if (no_holes && is_hole) {
4760 err |= FILE_EXTENT_ERROR;
4761 error("root %llu EXTENT_DATA[%llu %llu] shouldn't be hole",
4762 root->objectid, fkey->objectid, fkey->offset);
4763 } else if (!no_holes && *end != fkey->offset) {
4764 err |= FILE_EXTENT_ERROR;
4765 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4766 root->objectid, fkey->objectid, fkey->offset);
4769 *end += extent_num_bytes;
4771 *size += extent_num_bytes;
4777 * Check INODE_ITEM and related ITEMs (the same inode number)
4778 * 1. check link count
4779 * 2. check inode ref/extref
4780 * 3. check dir item/index
4782 * @ext_ref: the EXTENDED_IREF feature
4784 * Return 0 if no error occurred.
4785 * Return >0 for error or hit the traversal is done(by error bitmap)
4787 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4788 unsigned int ext_ref)
4790 struct extent_buffer *node;
4791 struct btrfs_inode_item *ii;
4792 struct btrfs_key key;
4801 u64 extent_size = 0;
4803 unsigned int nodatasum;
4808 node = path->nodes[0];
4809 slot = path->slots[0];
4811 btrfs_item_key_to_cpu(node, &key, slot);
4812 inode_id = key.objectid;
4814 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4815 ret = btrfs_next_item(root, path);
4821 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4822 isize = btrfs_inode_size(node, ii);
4823 nbytes = btrfs_inode_nbytes(node, ii);
4824 mode = btrfs_inode_mode(node, ii);
4825 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4826 nlink = btrfs_inode_nlink(node, ii);
4827 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4830 ret = btrfs_next_item(root, path);
4832 /* out will fill 'err' rusing current statistics */
4834 } else if (ret > 0) {
4839 node = path->nodes[0];
4840 slot = path->slots[0];
4841 btrfs_item_key_to_cpu(node, &key, slot);
4842 if (key.objectid != inode_id)
4846 case BTRFS_INODE_REF_KEY:
4847 ret = check_inode_ref(root, &key, node, slot, &refs,
4851 case BTRFS_INODE_EXTREF_KEY:
4852 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4853 warning("root %llu EXTREF[%llu %llu] isn't supported",
4854 root->objectid, key.objectid,
4856 ret = check_inode_extref(root, &key, node, slot, &refs,
4860 case BTRFS_DIR_ITEM_KEY:
4861 case BTRFS_DIR_INDEX_KEY:
4863 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4864 root->objectid, inode_id,
4865 imode_to_type(mode), key.objectid,
4868 ret = check_dir_item(root, &key, node, slot, &size,
4872 case BTRFS_EXTENT_DATA_KEY:
4874 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4875 root->objectid, inode_id, key.objectid,
4878 ret = check_file_extent(root, &key, node, slot,
4879 nodatasum, &extent_size,
4883 case BTRFS_XATTR_ITEM_KEY:
4886 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4887 key.objectid, key.type, key.offset);
4892 /* verify INODE_ITEM nlink/isize/nbytes */
4895 err |= LINK_COUNT_ERROR;
4896 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4897 root->objectid, inode_id, nlink);
4901 * Just a warning, as dir inode nbytes is just an
4902 * instructive value.
4904 if (!IS_ALIGNED(nbytes, root->nodesize)) {
4905 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
4906 root->objectid, inode_id, root->nodesize);
4909 if (isize != size) {
4911 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
4912 root->objectid, inode_id, isize, size);
4915 if (nlink != refs) {
4916 err |= LINK_COUNT_ERROR;
4917 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
4918 root->objectid, inode_id, nlink, refs);
4919 } else if (!nlink) {
4923 if (!nbytes && !no_holes && extent_end < isize) {
4924 err |= NBYTES_ERROR;
4925 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
4926 root->objectid, inode_id, isize);
4929 if (nbytes != extent_size) {
4930 err |= NBYTES_ERROR;
4931 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
4932 root->objectid, inode_id, nbytes, extent_size);
4939 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4941 struct btrfs_path path;
4942 struct btrfs_key key;
4946 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4947 key.type = BTRFS_INODE_ITEM_KEY;
4950 /* For root being dropped, we don't need to check first inode */
4951 if (btrfs_root_refs(&root->root_item) == 0 &&
4952 btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
4956 btrfs_init_path(&path);
4958 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4963 err |= INODE_ITEM_MISSING;
4966 err |= check_inode_item(root, &path, ext_ref);
4971 btrfs_release_path(&path);
4976 * Iterate all item on the tree and call check_inode_item() to check.
4978 * @root: the root of the tree to be checked.
4979 * @ext_ref: the EXTENDED_IREF feature
4981 * Return 0 if no error found.
4982 * Return <0 for error.
4984 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
4986 struct btrfs_path path;
4987 struct node_refs nrefs;
4988 struct btrfs_root_item *root_item = &root->root_item;
4993 * We need to manually check the first inode item(256)
4994 * As the following traversal function will only start from
4995 * the first inode item in the leaf, if inode item(256) is missing
4996 * we will just skip it forever.
4998 ret = check_fs_first_inode(root, ext_ref);
5002 memset(&nrefs, 0, sizeof(nrefs));
5003 level = btrfs_header_level(root->node);
5004 btrfs_init_path(&path);
5006 if (btrfs_root_refs(root_item) > 0 ||
5007 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5008 path.nodes[level] = root->node;
5009 path.slots[level] = 0;
5010 extent_buffer_get(root->node);
5012 struct btrfs_key key;
5014 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5015 level = root_item->drop_level;
5016 path.lowest_level = level;
5017 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5024 wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5030 wret = walk_up_tree_v2(root, &path, &level);
5038 btrfs_release_path(&path);
5043 * Find the relative ref for root_ref and root_backref.
5045 * @root: the root of the root tree.
5046 * @ref_key: the key of the root ref.
5048 * Return 0 if no error occurred.
5050 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5051 struct extent_buffer *node, int slot)
5053 struct btrfs_path path;
5054 struct btrfs_key key;
5055 struct btrfs_root_ref *ref;
5056 struct btrfs_root_ref *backref;
5057 char ref_name[BTRFS_NAME_LEN] = {0};
5058 char backref_name[BTRFS_NAME_LEN] = {0};
5064 u32 backref_namelen;
5069 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5070 ref_dirid = btrfs_root_ref_dirid(node, ref);
5071 ref_seq = btrfs_root_ref_sequence(node, ref);
5072 ref_namelen = btrfs_root_ref_name_len(node, ref);
5074 if (ref_namelen <= BTRFS_NAME_LEN) {
5077 len = BTRFS_NAME_LEN;
5078 warning("%s[%llu %llu] ref_name too long",
5079 ref_key->type == BTRFS_ROOT_REF_KEY ?
5080 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5083 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5085 /* Find relative root_ref */
5086 key.objectid = ref_key->offset;
5087 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5088 key.offset = ref_key->objectid;
5090 btrfs_init_path(&path);
5091 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5093 err |= ROOT_REF_MISSING;
5094 error("%s[%llu %llu] couldn't find relative ref",
5095 ref_key->type == BTRFS_ROOT_REF_KEY ?
5096 "ROOT_REF" : "ROOT_BACKREF",
5097 ref_key->objectid, ref_key->offset);
5101 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5102 struct btrfs_root_ref);
5103 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5104 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5105 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5107 if (backref_namelen <= BTRFS_NAME_LEN) {
5108 len = backref_namelen;
5110 len = BTRFS_NAME_LEN;
5111 warning("%s[%llu %llu] ref_name too long",
5112 key.type == BTRFS_ROOT_REF_KEY ?
5113 "ROOT_REF" : "ROOT_BACKREF",
5114 key.objectid, key.offset);
5116 read_extent_buffer(path.nodes[0], backref_name,
5117 (unsigned long)(backref + 1), len);
5119 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5120 ref_namelen != backref_namelen ||
5121 strncmp(ref_name, backref_name, len)) {
5122 err |= ROOT_REF_MISMATCH;
5123 error("%s[%llu %llu] mismatch relative ref",
5124 ref_key->type == BTRFS_ROOT_REF_KEY ?
5125 "ROOT_REF" : "ROOT_BACKREF",
5126 ref_key->objectid, ref_key->offset);
5129 btrfs_release_path(&path);
5134 * Check all fs/file tree in low_memory mode.
5136 * 1. for fs tree root item, call check_fs_root_v2()
5137 * 2. for fs tree root ref/backref, call check_root_ref()
5139 * Return 0 if no error occurred.
5141 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5143 struct btrfs_root *tree_root = fs_info->tree_root;
5144 struct btrfs_root *cur_root = NULL;
5145 struct btrfs_path path;
5146 struct btrfs_key key;
5147 struct extent_buffer *node;
5148 unsigned int ext_ref;
5153 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5155 btrfs_init_path(&path);
5156 key.objectid = BTRFS_FS_TREE_OBJECTID;
5158 key.type = BTRFS_ROOT_ITEM_KEY;
5160 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5164 } else if (ret > 0) {
5170 node = path.nodes[0];
5171 slot = path.slots[0];
5172 btrfs_item_key_to_cpu(node, &key, slot);
5173 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5175 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5176 fs_root_objectid(key.objectid)) {
5177 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5178 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5181 key.offset = (u64)-1;
5182 cur_root = btrfs_read_fs_root(fs_info, &key);
5185 if (IS_ERR(cur_root)) {
5186 error("Fail to read fs/subvol tree: %lld",
5192 ret = check_fs_root_v2(cur_root, ext_ref);
5195 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5196 btrfs_free_fs_root(cur_root);
5197 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5198 key.type == BTRFS_ROOT_BACKREF_KEY) {
5199 ret = check_root_ref(tree_root, &key, node, slot);
5203 ret = btrfs_next_item(tree_root, &path);
5213 btrfs_release_path(&path);
5217 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5219 struct list_head *cur = rec->backrefs.next;
5220 struct extent_backref *back;
5221 struct tree_backref *tback;
5222 struct data_backref *dback;
5226 while(cur != &rec->backrefs) {
5227 back = to_extent_backref(cur);
5229 if (!back->found_extent_tree) {
5233 if (back->is_data) {
5234 dback = to_data_backref(back);
5235 fprintf(stderr, "Backref %llu %s %llu"
5236 " owner %llu offset %llu num_refs %lu"
5237 " not found in extent tree\n",
5238 (unsigned long long)rec->start,
5239 back->full_backref ?
5241 back->full_backref ?
5242 (unsigned long long)dback->parent:
5243 (unsigned long long)dback->root,
5244 (unsigned long long)dback->owner,
5245 (unsigned long long)dback->offset,
5246 (unsigned long)dback->num_refs);
5248 tback = to_tree_backref(back);
5249 fprintf(stderr, "Backref %llu parent %llu"
5250 " root %llu not found in extent tree\n",
5251 (unsigned long long)rec->start,
5252 (unsigned long long)tback->parent,
5253 (unsigned long long)tback->root);
5256 if (!back->is_data && !back->found_ref) {
5260 tback = to_tree_backref(back);
5261 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5262 (unsigned long long)rec->start,
5263 back->full_backref ? "parent" : "root",
5264 back->full_backref ?
5265 (unsigned long long)tback->parent :
5266 (unsigned long long)tback->root, back);
5268 if (back->is_data) {
5269 dback = to_data_backref(back);
5270 if (dback->found_ref != dback->num_refs) {
5274 fprintf(stderr, "Incorrect local backref count"
5275 " on %llu %s %llu owner %llu"
5276 " offset %llu found %u wanted %u back %p\n",
5277 (unsigned long long)rec->start,
5278 back->full_backref ?
5280 back->full_backref ?
5281 (unsigned long long)dback->parent:
5282 (unsigned long long)dback->root,
5283 (unsigned long long)dback->owner,
5284 (unsigned long long)dback->offset,
5285 dback->found_ref, dback->num_refs, back);
5287 if (dback->disk_bytenr != rec->start) {
5291 fprintf(stderr, "Backref disk bytenr does not"
5292 " match extent record, bytenr=%llu, "
5293 "ref bytenr=%llu\n",
5294 (unsigned long long)rec->start,
5295 (unsigned long long)dback->disk_bytenr);
5298 if (dback->bytes != rec->nr) {
5302 fprintf(stderr, "Backref bytes do not match "
5303 "extent backref, bytenr=%llu, ref "
5304 "bytes=%llu, backref bytes=%llu\n",
5305 (unsigned long long)rec->start,
5306 (unsigned long long)rec->nr,
5307 (unsigned long long)dback->bytes);
5310 if (!back->is_data) {
5313 dback = to_data_backref(back);
5314 found += dback->found_ref;
5317 if (found != rec->refs) {
5321 fprintf(stderr, "Incorrect global backref count "
5322 "on %llu found %llu wanted %llu\n",
5323 (unsigned long long)rec->start,
5324 (unsigned long long)found,
5325 (unsigned long long)rec->refs);
5331 static int free_all_extent_backrefs(struct extent_record *rec)
5333 struct extent_backref *back;
5334 struct list_head *cur;
5335 while (!list_empty(&rec->backrefs)) {
5336 cur = rec->backrefs.next;
5337 back = to_extent_backref(cur);
5344 static void free_extent_record_cache(struct btrfs_fs_info *fs_info,
5345 struct cache_tree *extent_cache)
5347 struct cache_extent *cache;
5348 struct extent_record *rec;
5351 cache = first_cache_extent(extent_cache);
5354 rec = container_of(cache, struct extent_record, cache);
5355 remove_cache_extent(extent_cache, cache);
5356 free_all_extent_backrefs(rec);
5361 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5362 struct extent_record *rec)
5364 if (rec->content_checked && rec->owner_ref_checked &&
5365 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5366 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5367 !rec->bad_full_backref && !rec->crossing_stripes &&
5368 !rec->wrong_chunk_type) {
5369 remove_cache_extent(extent_cache, &rec->cache);
5370 free_all_extent_backrefs(rec);
5371 list_del_init(&rec->list);
5377 static int check_owner_ref(struct btrfs_root *root,
5378 struct extent_record *rec,
5379 struct extent_buffer *buf)
5381 struct extent_backref *node;
5382 struct tree_backref *back;
5383 struct btrfs_root *ref_root;
5384 struct btrfs_key key;
5385 struct btrfs_path path;
5386 struct extent_buffer *parent;
5391 list_for_each_entry(node, &rec->backrefs, list) {
5394 if (!node->found_ref)
5396 if (node->full_backref)
5398 back = to_tree_backref(node);
5399 if (btrfs_header_owner(buf) == back->root)
5402 BUG_ON(rec->is_root);
5404 /* try to find the block by search corresponding fs tree */
5405 key.objectid = btrfs_header_owner(buf);
5406 key.type = BTRFS_ROOT_ITEM_KEY;
5407 key.offset = (u64)-1;
5409 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5410 if (IS_ERR(ref_root))
5413 level = btrfs_header_level(buf);
5415 btrfs_item_key_to_cpu(buf, &key, 0);
5417 btrfs_node_key_to_cpu(buf, &key, 0);
5419 btrfs_init_path(&path);
5420 path.lowest_level = level + 1;
5421 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5425 parent = path.nodes[level + 1];
5426 if (parent && buf->start == btrfs_node_blockptr(parent,
5427 path.slots[level + 1]))
5430 btrfs_release_path(&path);
5431 return found ? 0 : 1;
5434 static int is_extent_tree_record(struct extent_record *rec)
5436 struct list_head *cur = rec->backrefs.next;
5437 struct extent_backref *node;
5438 struct tree_backref *back;
5441 while(cur != &rec->backrefs) {
5442 node = to_extent_backref(cur);
5446 back = to_tree_backref(node);
5447 if (node->full_backref)
5449 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5456 static int record_bad_block_io(struct btrfs_fs_info *info,
5457 struct cache_tree *extent_cache,
5460 struct extent_record *rec;
5461 struct cache_extent *cache;
5462 struct btrfs_key key;
5464 cache = lookup_cache_extent(extent_cache, start, len);
5468 rec = container_of(cache, struct extent_record, cache);
5469 if (!is_extent_tree_record(rec))
5472 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5473 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5476 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5477 struct extent_buffer *buf, int slot)
5479 if (btrfs_header_level(buf)) {
5480 struct btrfs_key_ptr ptr1, ptr2;
5482 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5483 sizeof(struct btrfs_key_ptr));
5484 read_extent_buffer(buf, &ptr2,
5485 btrfs_node_key_ptr_offset(slot + 1),
5486 sizeof(struct btrfs_key_ptr));
5487 write_extent_buffer(buf, &ptr1,
5488 btrfs_node_key_ptr_offset(slot + 1),
5489 sizeof(struct btrfs_key_ptr));
5490 write_extent_buffer(buf, &ptr2,
5491 btrfs_node_key_ptr_offset(slot),
5492 sizeof(struct btrfs_key_ptr));
5494 struct btrfs_disk_key key;
5495 btrfs_node_key(buf, &key, 0);
5496 btrfs_fixup_low_keys(root, path, &key,
5497 btrfs_header_level(buf) + 1);
5500 struct btrfs_item *item1, *item2;
5501 struct btrfs_key k1, k2;
5502 char *item1_data, *item2_data;
5503 u32 item1_offset, item2_offset, item1_size, item2_size;
5505 item1 = btrfs_item_nr(slot);
5506 item2 = btrfs_item_nr(slot + 1);
5507 btrfs_item_key_to_cpu(buf, &k1, slot);
5508 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5509 item1_offset = btrfs_item_offset(buf, item1);
5510 item2_offset = btrfs_item_offset(buf, item2);
5511 item1_size = btrfs_item_size(buf, item1);
5512 item2_size = btrfs_item_size(buf, item2);
5514 item1_data = malloc(item1_size);
5517 item2_data = malloc(item2_size);
5523 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5524 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5526 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5527 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5531 btrfs_set_item_offset(buf, item1, item2_offset);
5532 btrfs_set_item_offset(buf, item2, item1_offset);
5533 btrfs_set_item_size(buf, item1, item2_size);
5534 btrfs_set_item_size(buf, item2, item1_size);
5536 path->slots[0] = slot;
5537 btrfs_set_item_key_unsafe(root, path, &k2);
5538 path->slots[0] = slot + 1;
5539 btrfs_set_item_key_unsafe(root, path, &k1);
5544 static int fix_key_order(struct btrfs_trans_handle *trans,
5545 struct btrfs_root *root,
5546 struct btrfs_path *path)
5548 struct extent_buffer *buf;
5549 struct btrfs_key k1, k2;
5551 int level = path->lowest_level;
5554 buf = path->nodes[level];
5555 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5557 btrfs_node_key_to_cpu(buf, &k1, i);
5558 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5560 btrfs_item_key_to_cpu(buf, &k1, i);
5561 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5563 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5565 ret = swap_values(root, path, buf, i);
5568 btrfs_mark_buffer_dirty(buf);
5574 static int delete_bogus_item(struct btrfs_trans_handle *trans,
5575 struct btrfs_root *root,
5576 struct btrfs_path *path,
5577 struct extent_buffer *buf, int slot)
5579 struct btrfs_key key;
5580 int nritems = btrfs_header_nritems(buf);
5582 btrfs_item_key_to_cpu(buf, &key, slot);
5584 /* These are all the keys we can deal with missing. */
5585 if (key.type != BTRFS_DIR_INDEX_KEY &&
5586 key.type != BTRFS_EXTENT_ITEM_KEY &&
5587 key.type != BTRFS_METADATA_ITEM_KEY &&
5588 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5589 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5592 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5593 (unsigned long long)key.objectid, key.type,
5594 (unsigned long long)key.offset, slot, buf->start);
5595 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5596 btrfs_item_nr_offset(slot + 1),
5597 sizeof(struct btrfs_item) *
5598 (nritems - slot - 1));
5599 btrfs_set_header_nritems(buf, nritems - 1);
5601 struct btrfs_disk_key disk_key;
5603 btrfs_item_key(buf, &disk_key, 0);
5604 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5606 btrfs_mark_buffer_dirty(buf);
5610 static int fix_item_offset(struct btrfs_trans_handle *trans,
5611 struct btrfs_root *root,
5612 struct btrfs_path *path)
5614 struct extent_buffer *buf;
5618 /* We should only get this for leaves */
5619 BUG_ON(path->lowest_level);
5620 buf = path->nodes[0];
5622 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5623 unsigned int shift = 0, offset;
5625 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5626 BTRFS_LEAF_DATA_SIZE(root)) {
5627 if (btrfs_item_end_nr(buf, i) >
5628 BTRFS_LEAF_DATA_SIZE(root)) {
5629 ret = delete_bogus_item(trans, root, path,
5633 fprintf(stderr, "item is off the end of the "
5634 "leaf, can't fix\n");
5638 shift = BTRFS_LEAF_DATA_SIZE(root) -
5639 btrfs_item_end_nr(buf, i);
5640 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5641 btrfs_item_offset_nr(buf, i - 1)) {
5642 if (btrfs_item_end_nr(buf, i) >
5643 btrfs_item_offset_nr(buf, i - 1)) {
5644 ret = delete_bogus_item(trans, root, path,
5648 fprintf(stderr, "items overlap, can't fix\n");
5652 shift = btrfs_item_offset_nr(buf, i - 1) -
5653 btrfs_item_end_nr(buf, i);
5658 printf("Shifting item nr %d by %u bytes in block %llu\n",
5659 i, shift, (unsigned long long)buf->start);
5660 offset = btrfs_item_offset_nr(buf, i);
5661 memmove_extent_buffer(buf,
5662 btrfs_leaf_data(buf) + offset + shift,
5663 btrfs_leaf_data(buf) + offset,
5664 btrfs_item_size_nr(buf, i));
5665 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5667 btrfs_mark_buffer_dirty(buf);
5671 * We may have moved things, in which case we want to exit so we don't
5672 * write those changes out. Once we have proper abort functionality in
5673 * progs this can be changed to something nicer.
5680 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5681 * then just return -EIO.
5683 static int try_to_fix_bad_block(struct btrfs_root *root,
5684 struct extent_buffer *buf,
5685 enum btrfs_tree_block_status status)
5687 struct btrfs_trans_handle *trans;
5688 struct ulist *roots;
5689 struct ulist_node *node;
5690 struct btrfs_root *search_root;
5691 struct btrfs_path path;
5692 struct ulist_iterator iter;
5693 struct btrfs_key root_key, key;
5696 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5697 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5700 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5704 btrfs_init_path(&path);
5705 ULIST_ITER_INIT(&iter);
5706 while ((node = ulist_next(roots, &iter))) {
5707 root_key.objectid = node->val;
5708 root_key.type = BTRFS_ROOT_ITEM_KEY;
5709 root_key.offset = (u64)-1;
5711 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5718 trans = btrfs_start_transaction(search_root, 0);
5719 if (IS_ERR(trans)) {
5720 ret = PTR_ERR(trans);
5724 path.lowest_level = btrfs_header_level(buf);
5725 path.skip_check_block = 1;
5726 if (path.lowest_level)
5727 btrfs_node_key_to_cpu(buf, &key, 0);
5729 btrfs_item_key_to_cpu(buf, &key, 0);
5730 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5733 btrfs_commit_transaction(trans, search_root);
5736 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5737 ret = fix_key_order(trans, search_root, &path);
5738 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5739 ret = fix_item_offset(trans, search_root, &path);
5741 btrfs_commit_transaction(trans, search_root);
5744 btrfs_release_path(&path);
5745 btrfs_commit_transaction(trans, search_root);
5748 btrfs_release_path(&path);
5752 static int check_block(struct btrfs_root *root,
5753 struct cache_tree *extent_cache,
5754 struct extent_buffer *buf, u64 flags)
5756 struct extent_record *rec;
5757 struct cache_extent *cache;
5758 struct btrfs_key key;
5759 enum btrfs_tree_block_status status;
5763 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5766 rec = container_of(cache, struct extent_record, cache);
5767 rec->generation = btrfs_header_generation(buf);
5769 level = btrfs_header_level(buf);
5770 if (btrfs_header_nritems(buf) > 0) {
5773 btrfs_item_key_to_cpu(buf, &key, 0);
5775 btrfs_node_key_to_cpu(buf, &key, 0);
5777 rec->info_objectid = key.objectid;
5779 rec->info_level = level;
5781 if (btrfs_is_leaf(buf))
5782 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5784 status = btrfs_check_node(root, &rec->parent_key, buf);
5786 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5788 status = try_to_fix_bad_block(root, buf, status);
5789 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5791 fprintf(stderr, "bad block %llu\n",
5792 (unsigned long long)buf->start);
5795 * Signal to callers we need to start the scan over
5796 * again since we'll have cowed blocks.
5801 rec->content_checked = 1;
5802 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5803 rec->owner_ref_checked = 1;
5805 ret = check_owner_ref(root, rec, buf);
5807 rec->owner_ref_checked = 1;
5811 maybe_free_extent_rec(extent_cache, rec);
5815 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5816 u64 parent, u64 root)
5818 struct list_head *cur = rec->backrefs.next;
5819 struct extent_backref *node;
5820 struct tree_backref *back;
5822 while(cur != &rec->backrefs) {
5823 node = to_extent_backref(cur);
5827 back = to_tree_backref(node);
5829 if (!node->full_backref)
5831 if (parent == back->parent)
5834 if (node->full_backref)
5836 if (back->root == root)
5843 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5844 u64 parent, u64 root)
5846 struct tree_backref *ref = malloc(sizeof(*ref));
5850 memset(&ref->node, 0, sizeof(ref->node));
5852 ref->parent = parent;
5853 ref->node.full_backref = 1;
5856 ref->node.full_backref = 0;
5858 list_add_tail(&ref->node.list, &rec->backrefs);
5863 static struct data_backref *find_data_backref(struct extent_record *rec,
5864 u64 parent, u64 root,
5865 u64 owner, u64 offset,
5867 u64 disk_bytenr, u64 bytes)
5869 struct list_head *cur = rec->backrefs.next;
5870 struct extent_backref *node;
5871 struct data_backref *back;
5873 while(cur != &rec->backrefs) {
5874 node = to_extent_backref(cur);
5878 back = to_data_backref(node);
5880 if (!node->full_backref)
5882 if (parent == back->parent)
5885 if (node->full_backref)
5887 if (back->root == root && back->owner == owner &&
5888 back->offset == offset) {
5889 if (found_ref && node->found_ref &&
5890 (back->bytes != bytes ||
5891 back->disk_bytenr != disk_bytenr))
5900 static struct data_backref *alloc_data_backref(struct extent_record *rec,
5901 u64 parent, u64 root,
5902 u64 owner, u64 offset,
5905 struct data_backref *ref = malloc(sizeof(*ref));
5909 memset(&ref->node, 0, sizeof(ref->node));
5910 ref->node.is_data = 1;
5913 ref->parent = parent;
5916 ref->node.full_backref = 1;
5920 ref->offset = offset;
5921 ref->node.full_backref = 0;
5923 ref->bytes = max_size;
5926 list_add_tail(&ref->node.list, &rec->backrefs);
5927 if (max_size > rec->max_size)
5928 rec->max_size = max_size;
5932 /* Check if the type of extent matches with its chunk */
5933 static void check_extent_type(struct extent_record *rec)
5935 struct btrfs_block_group_cache *bg_cache;
5937 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
5941 /* data extent, check chunk directly*/
5942 if (!rec->metadata) {
5943 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
5944 rec->wrong_chunk_type = 1;
5948 /* metadata extent, check the obvious case first */
5949 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
5950 BTRFS_BLOCK_GROUP_METADATA))) {
5951 rec->wrong_chunk_type = 1;
5956 * Check SYSTEM extent, as it's also marked as metadata, we can only
5957 * make sure it's a SYSTEM extent by its backref
5959 if (!list_empty(&rec->backrefs)) {
5960 struct extent_backref *node;
5961 struct tree_backref *tback;
5964 node = to_extent_backref(rec->backrefs.next);
5965 if (node->is_data) {
5966 /* tree block shouldn't have data backref */
5967 rec->wrong_chunk_type = 1;
5970 tback = container_of(node, struct tree_backref, node);
5972 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
5973 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
5975 bg_type = BTRFS_BLOCK_GROUP_METADATA;
5976 if (!(bg_cache->flags & bg_type))
5977 rec->wrong_chunk_type = 1;
5982 * Allocate a new extent record, fill default values from @tmpl and insert int
5983 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
5984 * the cache, otherwise it fails.
5986 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
5987 struct extent_record *tmpl)
5989 struct extent_record *rec;
5992 rec = malloc(sizeof(*rec));
5995 rec->start = tmpl->start;
5996 rec->max_size = tmpl->max_size;
5997 rec->nr = max(tmpl->nr, tmpl->max_size);
5998 rec->found_rec = tmpl->found_rec;
5999 rec->content_checked = tmpl->content_checked;
6000 rec->owner_ref_checked = tmpl->owner_ref_checked;
6001 rec->num_duplicates = 0;
6002 rec->metadata = tmpl->metadata;
6003 rec->flag_block_full_backref = FLAG_UNSET;
6004 rec->bad_full_backref = 0;
6005 rec->crossing_stripes = 0;
6006 rec->wrong_chunk_type = 0;
6007 rec->is_root = tmpl->is_root;
6008 rec->refs = tmpl->refs;
6009 rec->extent_item_refs = tmpl->extent_item_refs;
6010 rec->parent_generation = tmpl->parent_generation;
6011 INIT_LIST_HEAD(&rec->backrefs);
6012 INIT_LIST_HEAD(&rec->dups);
6013 INIT_LIST_HEAD(&rec->list);
6014 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6015 rec->cache.start = tmpl->start;
6016 rec->cache.size = tmpl->nr;
6017 ret = insert_cache_extent(extent_cache, &rec->cache);
6022 bytes_used += rec->nr;
6025 rec->crossing_stripes = check_crossing_stripes(global_info,
6026 rec->start, global_info->tree_root->nodesize);
6027 check_extent_type(rec);
6032 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6034 * - refs - if found, increase refs
6035 * - is_root - if found, set
6036 * - content_checked - if found, set
6037 * - owner_ref_checked - if found, set
6039 * If not found, create a new one, initialize and insert.
6041 static int add_extent_rec(struct cache_tree *extent_cache,
6042 struct extent_record *tmpl)
6044 struct extent_record *rec;
6045 struct cache_extent *cache;
6049 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6051 rec = container_of(cache, struct extent_record, cache);
6055 rec->nr = max(tmpl->nr, tmpl->max_size);
6058 * We need to make sure to reset nr to whatever the extent
6059 * record says was the real size, this way we can compare it to
6062 if (tmpl->found_rec) {
6063 if (tmpl->start != rec->start || rec->found_rec) {
6064 struct extent_record *tmp;
6067 if (list_empty(&rec->list))
6068 list_add_tail(&rec->list,
6069 &duplicate_extents);
6072 * We have to do this song and dance in case we
6073 * find an extent record that falls inside of
6074 * our current extent record but does not have
6075 * the same objectid.
6077 tmp = malloc(sizeof(*tmp));
6080 tmp->start = tmpl->start;
6081 tmp->max_size = tmpl->max_size;
6084 tmp->metadata = tmpl->metadata;
6085 tmp->extent_item_refs = tmpl->extent_item_refs;
6086 INIT_LIST_HEAD(&tmp->list);
6087 list_add_tail(&tmp->list, &rec->dups);
6088 rec->num_duplicates++;
6095 if (tmpl->extent_item_refs && !dup) {
6096 if (rec->extent_item_refs) {
6097 fprintf(stderr, "block %llu rec "
6098 "extent_item_refs %llu, passed %llu\n",
6099 (unsigned long long)tmpl->start,
6100 (unsigned long long)
6101 rec->extent_item_refs,
6102 (unsigned long long)tmpl->extent_item_refs);
6104 rec->extent_item_refs = tmpl->extent_item_refs;
6108 if (tmpl->content_checked)
6109 rec->content_checked = 1;
6110 if (tmpl->owner_ref_checked)
6111 rec->owner_ref_checked = 1;
6112 memcpy(&rec->parent_key, &tmpl->parent_key,
6113 sizeof(tmpl->parent_key));
6114 if (tmpl->parent_generation)
6115 rec->parent_generation = tmpl->parent_generation;
6116 if (rec->max_size < tmpl->max_size)
6117 rec->max_size = tmpl->max_size;
6120 * A metadata extent can't cross stripe_len boundary, otherwise
6121 * kernel scrub won't be able to handle it.
6122 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6126 rec->crossing_stripes = check_crossing_stripes(
6127 global_info, rec->start,
6128 global_info->tree_root->nodesize);
6129 check_extent_type(rec);
6130 maybe_free_extent_rec(extent_cache, rec);
6134 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6139 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6140 u64 parent, u64 root, int found_ref)
6142 struct extent_record *rec;
6143 struct tree_backref *back;
6144 struct cache_extent *cache;
6147 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6149 struct extent_record tmpl;
6151 memset(&tmpl, 0, sizeof(tmpl));
6152 tmpl.start = bytenr;
6156 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6160 /* really a bug in cache_extent implement now */
6161 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6166 rec = container_of(cache, struct extent_record, cache);
6167 if (rec->start != bytenr) {
6169 * Several cause, from unaligned bytenr to over lapping extents
6174 back = find_tree_backref(rec, parent, root);
6176 back = alloc_tree_backref(rec, parent, root);
6182 if (back->node.found_ref) {
6183 fprintf(stderr, "Extent back ref already exists "
6184 "for %llu parent %llu root %llu \n",
6185 (unsigned long long)bytenr,
6186 (unsigned long long)parent,
6187 (unsigned long long)root);
6189 back->node.found_ref = 1;
6191 if (back->node.found_extent_tree) {
6192 fprintf(stderr, "Extent back ref already exists "
6193 "for %llu parent %llu root %llu \n",
6194 (unsigned long long)bytenr,
6195 (unsigned long long)parent,
6196 (unsigned long long)root);
6198 back->node.found_extent_tree = 1;
6200 check_extent_type(rec);
6201 maybe_free_extent_rec(extent_cache, rec);
6205 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6206 u64 parent, u64 root, u64 owner, u64 offset,
6207 u32 num_refs, int found_ref, u64 max_size)
6209 struct extent_record *rec;
6210 struct data_backref *back;
6211 struct cache_extent *cache;
6214 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6216 struct extent_record tmpl;
6218 memset(&tmpl, 0, sizeof(tmpl));
6219 tmpl.start = bytenr;
6221 tmpl.max_size = max_size;
6223 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6227 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6232 rec = container_of(cache, struct extent_record, cache);
6233 if (rec->max_size < max_size)
6234 rec->max_size = max_size;
6237 * If found_ref is set then max_size is the real size and must match the
6238 * existing refs. So if we have already found a ref then we need to
6239 * make sure that this ref matches the existing one, otherwise we need
6240 * to add a new backref so we can notice that the backrefs don't match
6241 * and we need to figure out who is telling the truth. This is to
6242 * account for that awful fsync bug I introduced where we'd end up with
6243 * a btrfs_file_extent_item that would have its length include multiple
6244 * prealloc extents or point inside of a prealloc extent.
6246 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6249 back = alloc_data_backref(rec, parent, root, owner, offset,
6255 BUG_ON(num_refs != 1);
6256 if (back->node.found_ref)
6257 BUG_ON(back->bytes != max_size);
6258 back->node.found_ref = 1;
6259 back->found_ref += 1;
6260 back->bytes = max_size;
6261 back->disk_bytenr = bytenr;
6263 rec->content_checked = 1;
6264 rec->owner_ref_checked = 1;
6266 if (back->node.found_extent_tree) {
6267 fprintf(stderr, "Extent back ref already exists "
6268 "for %llu parent %llu root %llu "
6269 "owner %llu offset %llu num_refs %lu\n",
6270 (unsigned long long)bytenr,
6271 (unsigned long long)parent,
6272 (unsigned long long)root,
6273 (unsigned long long)owner,
6274 (unsigned long long)offset,
6275 (unsigned long)num_refs);
6277 back->num_refs = num_refs;
6278 back->node.found_extent_tree = 1;
6280 maybe_free_extent_rec(extent_cache, rec);
6284 static int add_pending(struct cache_tree *pending,
6285 struct cache_tree *seen, u64 bytenr, u32 size)
6288 ret = add_cache_extent(seen, bytenr, size);
6291 add_cache_extent(pending, bytenr, size);
6295 static int pick_next_pending(struct cache_tree *pending,
6296 struct cache_tree *reada,
6297 struct cache_tree *nodes,
6298 u64 last, struct block_info *bits, int bits_nr,
6301 unsigned long node_start = last;
6302 struct cache_extent *cache;
6305 cache = search_cache_extent(reada, 0);
6307 bits[0].start = cache->start;
6308 bits[0].size = cache->size;
6313 if (node_start > 32768)
6314 node_start -= 32768;
6316 cache = search_cache_extent(nodes, node_start);
6318 cache = search_cache_extent(nodes, 0);
6321 cache = search_cache_extent(pending, 0);
6326 bits[ret].start = cache->start;
6327 bits[ret].size = cache->size;
6328 cache = next_cache_extent(cache);
6330 } while (cache && ret < bits_nr);
6336 bits[ret].start = cache->start;
6337 bits[ret].size = cache->size;
6338 cache = next_cache_extent(cache);
6340 } while (cache && ret < bits_nr);
6342 if (bits_nr - ret > 8) {
6343 u64 lookup = bits[0].start + bits[0].size;
6344 struct cache_extent *next;
6345 next = search_cache_extent(pending, lookup);
6347 if (next->start - lookup > 32768)
6349 bits[ret].start = next->start;
6350 bits[ret].size = next->size;
6351 lookup = next->start + next->size;
6355 next = next_cache_extent(next);
6363 static void free_chunk_record(struct cache_extent *cache)
6365 struct chunk_record *rec;
6367 rec = container_of(cache, struct chunk_record, cache);
6368 list_del_init(&rec->list);
6369 list_del_init(&rec->dextents);
6373 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6375 cache_tree_free_extents(chunk_cache, free_chunk_record);
6378 static void free_device_record(struct rb_node *node)
6380 struct device_record *rec;
6382 rec = container_of(node, struct device_record, node);
6386 FREE_RB_BASED_TREE(device_cache, free_device_record);
6388 int insert_block_group_record(struct block_group_tree *tree,
6389 struct block_group_record *bg_rec)
6393 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6397 list_add_tail(&bg_rec->list, &tree->block_groups);
6401 static void free_block_group_record(struct cache_extent *cache)
6403 struct block_group_record *rec;
6405 rec = container_of(cache, struct block_group_record, cache);
6406 list_del_init(&rec->list);
6410 void free_block_group_tree(struct block_group_tree *tree)
6412 cache_tree_free_extents(&tree->tree, free_block_group_record);
6415 int insert_device_extent_record(struct device_extent_tree *tree,
6416 struct device_extent_record *de_rec)
6421 * Device extent is a bit different from the other extents, because
6422 * the extents which belong to the different devices may have the
6423 * same start and size, so we need use the special extent cache
6424 * search/insert functions.
6426 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6430 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6431 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6435 static void free_device_extent_record(struct cache_extent *cache)
6437 struct device_extent_record *rec;
6439 rec = container_of(cache, struct device_extent_record, cache);
6440 if (!list_empty(&rec->chunk_list))
6441 list_del_init(&rec->chunk_list);
6442 if (!list_empty(&rec->device_list))
6443 list_del_init(&rec->device_list);
6447 void free_device_extent_tree(struct device_extent_tree *tree)
6449 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6452 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6453 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6454 struct extent_buffer *leaf, int slot)
6456 struct btrfs_extent_ref_v0 *ref0;
6457 struct btrfs_key key;
6460 btrfs_item_key_to_cpu(leaf, &key, slot);
6461 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6462 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6463 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6466 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6467 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6473 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6474 struct btrfs_key *key,
6477 struct btrfs_chunk *ptr;
6478 struct chunk_record *rec;
6481 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6482 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6484 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6486 fprintf(stderr, "memory allocation failed\n");
6490 INIT_LIST_HEAD(&rec->list);
6491 INIT_LIST_HEAD(&rec->dextents);
6494 rec->cache.start = key->offset;
6495 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6497 rec->generation = btrfs_header_generation(leaf);
6499 rec->objectid = key->objectid;
6500 rec->type = key->type;
6501 rec->offset = key->offset;
6503 rec->length = rec->cache.size;
6504 rec->owner = btrfs_chunk_owner(leaf, ptr);
6505 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6506 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6507 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6508 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6509 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6510 rec->num_stripes = num_stripes;
6511 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6513 for (i = 0; i < rec->num_stripes; ++i) {
6514 rec->stripes[i].devid =
6515 btrfs_stripe_devid_nr(leaf, ptr, i);
6516 rec->stripes[i].offset =
6517 btrfs_stripe_offset_nr(leaf, ptr, i);
6518 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6519 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6526 static int process_chunk_item(struct cache_tree *chunk_cache,
6527 struct btrfs_key *key, struct extent_buffer *eb,
6530 struct chunk_record *rec;
6531 struct btrfs_chunk *chunk;
6534 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6536 * Do extra check for this chunk item,
6538 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6539 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6540 * and owner<->key_type check.
6542 ret = btrfs_check_chunk_valid(global_info->tree_root, eb, chunk, slot,
6545 error("chunk(%llu, %llu) is not valid, ignore it",
6546 key->offset, btrfs_chunk_length(eb, chunk));
6549 rec = btrfs_new_chunk_record(eb, key, slot);
6550 ret = insert_cache_extent(chunk_cache, &rec->cache);
6552 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6553 rec->offset, rec->length);
6560 static int process_device_item(struct rb_root *dev_cache,
6561 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6563 struct btrfs_dev_item *ptr;
6564 struct device_record *rec;
6567 ptr = btrfs_item_ptr(eb,
6568 slot, struct btrfs_dev_item);
6570 rec = malloc(sizeof(*rec));
6572 fprintf(stderr, "memory allocation failed\n");
6576 rec->devid = key->offset;
6577 rec->generation = btrfs_header_generation(eb);
6579 rec->objectid = key->objectid;
6580 rec->type = key->type;
6581 rec->offset = key->offset;
6583 rec->devid = btrfs_device_id(eb, ptr);
6584 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6585 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6587 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6589 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6596 struct block_group_record *
6597 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6600 struct btrfs_block_group_item *ptr;
6601 struct block_group_record *rec;
6603 rec = calloc(1, sizeof(*rec));
6605 fprintf(stderr, "memory allocation failed\n");
6609 rec->cache.start = key->objectid;
6610 rec->cache.size = key->offset;
6612 rec->generation = btrfs_header_generation(leaf);
6614 rec->objectid = key->objectid;
6615 rec->type = key->type;
6616 rec->offset = key->offset;
6618 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6619 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6621 INIT_LIST_HEAD(&rec->list);
6626 static int process_block_group_item(struct block_group_tree *block_group_cache,
6627 struct btrfs_key *key,
6628 struct extent_buffer *eb, int slot)
6630 struct block_group_record *rec;
6633 rec = btrfs_new_block_group_record(eb, key, slot);
6634 ret = insert_block_group_record(block_group_cache, rec);
6636 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6637 rec->objectid, rec->offset);
6644 struct device_extent_record *
6645 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6646 struct btrfs_key *key, int slot)
6648 struct device_extent_record *rec;
6649 struct btrfs_dev_extent *ptr;
6651 rec = calloc(1, sizeof(*rec));
6653 fprintf(stderr, "memory allocation failed\n");
6657 rec->cache.objectid = key->objectid;
6658 rec->cache.start = key->offset;
6660 rec->generation = btrfs_header_generation(leaf);
6662 rec->objectid = key->objectid;
6663 rec->type = key->type;
6664 rec->offset = key->offset;
6666 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6667 rec->chunk_objecteid =
6668 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6670 btrfs_dev_extent_chunk_offset(leaf, ptr);
6671 rec->length = btrfs_dev_extent_length(leaf, ptr);
6672 rec->cache.size = rec->length;
6674 INIT_LIST_HEAD(&rec->chunk_list);
6675 INIT_LIST_HEAD(&rec->device_list);
6681 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6682 struct btrfs_key *key, struct extent_buffer *eb,
6685 struct device_extent_record *rec;
6688 rec = btrfs_new_device_extent_record(eb, key, slot);
6689 ret = insert_device_extent_record(dev_extent_cache, rec);
6692 "Device extent[%llu, %llu, %llu] existed.\n",
6693 rec->objectid, rec->offset, rec->length);
6700 static int process_extent_item(struct btrfs_root *root,
6701 struct cache_tree *extent_cache,
6702 struct extent_buffer *eb, int slot)
6704 struct btrfs_extent_item *ei;
6705 struct btrfs_extent_inline_ref *iref;
6706 struct btrfs_extent_data_ref *dref;
6707 struct btrfs_shared_data_ref *sref;
6708 struct btrfs_key key;
6709 struct extent_record tmpl;
6714 u32 item_size = btrfs_item_size_nr(eb, slot);
6720 btrfs_item_key_to_cpu(eb, &key, slot);
6722 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6724 num_bytes = root->nodesize;
6726 num_bytes = key.offset;
6729 if (!IS_ALIGNED(key.objectid, root->sectorsize)) {
6730 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6731 key.objectid, root->sectorsize);
6734 if (item_size < sizeof(*ei)) {
6735 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6736 struct btrfs_extent_item_v0 *ei0;
6737 BUG_ON(item_size != sizeof(*ei0));
6738 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6739 refs = btrfs_extent_refs_v0(eb, ei0);
6743 memset(&tmpl, 0, sizeof(tmpl));
6744 tmpl.start = key.objectid;
6745 tmpl.nr = num_bytes;
6746 tmpl.extent_item_refs = refs;
6747 tmpl.metadata = metadata;
6749 tmpl.max_size = num_bytes;
6751 return add_extent_rec(extent_cache, &tmpl);
6754 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6755 refs = btrfs_extent_refs(eb, ei);
6756 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6760 if (metadata && num_bytes != root->nodesize) {
6761 error("ignore invalid metadata extent, length %llu does not equal to %u",
6762 num_bytes, root->nodesize);
6765 if (!metadata && !IS_ALIGNED(num_bytes, root->sectorsize)) {
6766 error("ignore invalid data extent, length %llu is not aligned to %u",
6767 num_bytes, root->sectorsize);
6771 memset(&tmpl, 0, sizeof(tmpl));
6772 tmpl.start = key.objectid;
6773 tmpl.nr = num_bytes;
6774 tmpl.extent_item_refs = refs;
6775 tmpl.metadata = metadata;
6777 tmpl.max_size = num_bytes;
6778 add_extent_rec(extent_cache, &tmpl);
6780 ptr = (unsigned long)(ei + 1);
6781 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6782 key.type == BTRFS_EXTENT_ITEM_KEY)
6783 ptr += sizeof(struct btrfs_tree_block_info);
6785 end = (unsigned long)ei + item_size;
6787 iref = (struct btrfs_extent_inline_ref *)ptr;
6788 type = btrfs_extent_inline_ref_type(eb, iref);
6789 offset = btrfs_extent_inline_ref_offset(eb, iref);
6791 case BTRFS_TREE_BLOCK_REF_KEY:
6792 ret = add_tree_backref(extent_cache, key.objectid,
6795 error("add_tree_backref failed: %s",
6798 case BTRFS_SHARED_BLOCK_REF_KEY:
6799 ret = add_tree_backref(extent_cache, key.objectid,
6802 error("add_tree_backref failed: %s",
6805 case BTRFS_EXTENT_DATA_REF_KEY:
6806 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6807 add_data_backref(extent_cache, key.objectid, 0,
6808 btrfs_extent_data_ref_root(eb, dref),
6809 btrfs_extent_data_ref_objectid(eb,
6811 btrfs_extent_data_ref_offset(eb, dref),
6812 btrfs_extent_data_ref_count(eb, dref),
6815 case BTRFS_SHARED_DATA_REF_KEY:
6816 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6817 add_data_backref(extent_cache, key.objectid, offset,
6819 btrfs_shared_data_ref_count(eb, sref),
6823 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6824 key.objectid, key.type, num_bytes);
6827 ptr += btrfs_extent_inline_ref_size(type);
6834 static int check_cache_range(struct btrfs_root *root,
6835 struct btrfs_block_group_cache *cache,
6836 u64 offset, u64 bytes)
6838 struct btrfs_free_space *entry;
6844 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6845 bytenr = btrfs_sb_offset(i);
6846 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
6847 cache->key.objectid, bytenr, 0,
6848 &logical, &nr, &stripe_len);
6853 if (logical[nr] + stripe_len <= offset)
6855 if (offset + bytes <= logical[nr])
6857 if (logical[nr] == offset) {
6858 if (stripe_len >= bytes) {
6862 bytes -= stripe_len;
6863 offset += stripe_len;
6864 } else if (logical[nr] < offset) {
6865 if (logical[nr] + stripe_len >=
6870 bytes = (offset + bytes) -
6871 (logical[nr] + stripe_len);
6872 offset = logical[nr] + stripe_len;
6875 * Could be tricky, the super may land in the
6876 * middle of the area we're checking. First
6877 * check the easiest case, it's at the end.
6879 if (logical[nr] + stripe_len >=
6881 bytes = logical[nr] - offset;
6885 /* Check the left side */
6886 ret = check_cache_range(root, cache,
6888 logical[nr] - offset);
6894 /* Now we continue with the right side */
6895 bytes = (offset + bytes) -
6896 (logical[nr] + stripe_len);
6897 offset = logical[nr] + stripe_len;
6904 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
6906 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
6907 offset, offset+bytes);
6911 if (entry->offset != offset) {
6912 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
6917 if (entry->bytes != bytes) {
6918 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
6919 bytes, entry->bytes, offset);
6923 unlink_free_space(cache->free_space_ctl, entry);
6928 static int verify_space_cache(struct btrfs_root *root,
6929 struct btrfs_block_group_cache *cache)
6931 struct btrfs_path path;
6932 struct extent_buffer *leaf;
6933 struct btrfs_key key;
6937 root = root->fs_info->extent_root;
6939 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
6941 btrfs_init_path(&path);
6942 key.objectid = last;
6944 key.type = BTRFS_EXTENT_ITEM_KEY;
6945 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6950 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
6951 ret = btrfs_next_leaf(root, &path);
6959 leaf = path.nodes[0];
6960 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
6961 if (key.objectid >= cache->key.offset + cache->key.objectid)
6963 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
6964 key.type != BTRFS_METADATA_ITEM_KEY) {
6969 if (last == key.objectid) {
6970 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6971 last = key.objectid + key.offset;
6973 last = key.objectid + root->nodesize;
6978 ret = check_cache_range(root, cache, last,
6979 key.objectid - last);
6982 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6983 last = key.objectid + key.offset;
6985 last = key.objectid + root->nodesize;
6989 if (last < cache->key.objectid + cache->key.offset)
6990 ret = check_cache_range(root, cache, last,
6991 cache->key.objectid +
6992 cache->key.offset - last);
6995 btrfs_release_path(&path);
6998 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
6999 fprintf(stderr, "There are still entries left in the space "
7007 static int check_space_cache(struct btrfs_root *root)
7009 struct btrfs_block_group_cache *cache;
7010 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7014 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7015 btrfs_super_generation(root->fs_info->super_copy) !=
7016 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7017 printf("cache and super generation don't match, space cache "
7018 "will be invalidated\n");
7022 if (ctx.progress_enabled) {
7023 ctx.tp = TASK_FREE_SPACE;
7024 task_start(ctx.info);
7028 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7032 start = cache->key.objectid + cache->key.offset;
7033 if (!cache->free_space_ctl) {
7034 if (btrfs_init_free_space_ctl(cache,
7035 root->sectorsize)) {
7040 btrfs_remove_free_space_cache(cache);
7043 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7044 ret = exclude_super_stripes(root, cache);
7046 fprintf(stderr, "could not exclude super stripes: %s\n",
7051 ret = load_free_space_tree(root->fs_info, cache);
7052 free_excluded_extents(root, cache);
7054 fprintf(stderr, "could not load free space tree: %s\n",
7061 ret = load_free_space_cache(root->fs_info, cache);
7066 ret = verify_space_cache(root, cache);
7068 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7069 cache->key.objectid);
7074 task_stop(ctx.info);
7076 return error ? -EINVAL : 0;
7079 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7080 u64 num_bytes, unsigned long leaf_offset,
7081 struct extent_buffer *eb) {
7084 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7086 unsigned long csum_offset;
7090 u64 data_checked = 0;
7096 if (num_bytes % root->sectorsize)
7099 data = malloc(num_bytes);
7103 while (offset < num_bytes) {
7106 read_len = num_bytes - offset;
7107 /* read as much space once a time */
7108 ret = read_extent_data(root, data + offset,
7109 bytenr + offset, &read_len, mirror);
7113 /* verify every 4k data's checksum */
7114 while (data_checked < read_len) {
7116 tmp = offset + data_checked;
7118 csum = btrfs_csum_data((char *)data + tmp,
7119 csum, root->sectorsize);
7120 btrfs_csum_final(csum, (u8 *)&csum);
7122 csum_offset = leaf_offset +
7123 tmp / root->sectorsize * csum_size;
7124 read_extent_buffer(eb, (char *)&csum_expected,
7125 csum_offset, csum_size);
7126 /* try another mirror */
7127 if (csum != csum_expected) {
7128 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7129 mirror, bytenr + tmp,
7130 csum, csum_expected);
7131 num_copies = btrfs_num_copies(
7132 &root->fs_info->mapping_tree,
7134 if (mirror < num_copies - 1) {
7139 data_checked += root->sectorsize;
7148 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7151 struct btrfs_path path;
7152 struct extent_buffer *leaf;
7153 struct btrfs_key key;
7156 btrfs_init_path(&path);
7157 key.objectid = bytenr;
7158 key.type = BTRFS_EXTENT_ITEM_KEY;
7159 key.offset = (u64)-1;
7162 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7165 fprintf(stderr, "Error looking up extent record %d\n", ret);
7166 btrfs_release_path(&path);
7169 if (path.slots[0] > 0) {
7172 ret = btrfs_prev_leaf(root, &path);
7175 } else if (ret > 0) {
7182 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7185 * Block group items come before extent items if they have the same
7186 * bytenr, so walk back one more just in case. Dear future traveller,
7187 * first congrats on mastering time travel. Now if it's not too much
7188 * trouble could you go back to 2006 and tell Chris to make the
7189 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7190 * EXTENT_ITEM_KEY please?
7192 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7193 if (path.slots[0] > 0) {
7196 ret = btrfs_prev_leaf(root, &path);
7199 } else if (ret > 0) {
7204 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7208 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7209 ret = btrfs_next_leaf(root, &path);
7211 fprintf(stderr, "Error going to next leaf "
7213 btrfs_release_path(&path);
7219 leaf = path.nodes[0];
7220 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7221 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7225 if (key.objectid + key.offset < bytenr) {
7229 if (key.objectid > bytenr + num_bytes)
7232 if (key.objectid == bytenr) {
7233 if (key.offset >= num_bytes) {
7237 num_bytes -= key.offset;
7238 bytenr += key.offset;
7239 } else if (key.objectid < bytenr) {
7240 if (key.objectid + key.offset >= bytenr + num_bytes) {
7244 num_bytes = (bytenr + num_bytes) -
7245 (key.objectid + key.offset);
7246 bytenr = key.objectid + key.offset;
7248 if (key.objectid + key.offset < bytenr + num_bytes) {
7249 u64 new_start = key.objectid + key.offset;
7250 u64 new_bytes = bytenr + num_bytes - new_start;
7253 * Weird case, the extent is in the middle of
7254 * our range, we'll have to search one side
7255 * and then the other. Not sure if this happens
7256 * in real life, but no harm in coding it up
7257 * anyway just in case.
7259 btrfs_release_path(&path);
7260 ret = check_extent_exists(root, new_start,
7263 fprintf(stderr, "Right section didn't "
7267 num_bytes = key.objectid - bytenr;
7270 num_bytes = key.objectid - bytenr;
7277 if (num_bytes && !ret) {
7278 fprintf(stderr, "There are no extents for csum range "
7279 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7283 btrfs_release_path(&path);
7287 static int check_csums(struct btrfs_root *root)
7289 struct btrfs_path path;
7290 struct extent_buffer *leaf;
7291 struct btrfs_key key;
7292 u64 offset = 0, num_bytes = 0;
7293 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7297 unsigned long leaf_offset;
7299 root = root->fs_info->csum_root;
7300 if (!extent_buffer_uptodate(root->node)) {
7301 fprintf(stderr, "No valid csum tree found\n");
7305 btrfs_init_path(&path);
7306 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7307 key.type = BTRFS_EXTENT_CSUM_KEY;
7309 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7311 fprintf(stderr, "Error searching csum tree %d\n", ret);
7312 btrfs_release_path(&path);
7316 if (ret > 0 && path.slots[0])
7321 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7322 ret = btrfs_next_leaf(root, &path);
7324 fprintf(stderr, "Error going to next leaf "
7331 leaf = path.nodes[0];
7333 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7334 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7339 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7340 csum_size) * root->sectorsize;
7341 if (!check_data_csum)
7342 goto skip_csum_check;
7343 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7344 ret = check_extent_csums(root, key.offset, data_len,
7350 offset = key.offset;
7351 } else if (key.offset != offset + num_bytes) {
7352 ret = check_extent_exists(root, offset, num_bytes);
7354 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7355 "there is no extent record\n",
7356 offset, offset+num_bytes);
7359 offset = key.offset;
7362 num_bytes += data_len;
7366 btrfs_release_path(&path);
7370 static int is_dropped_key(struct btrfs_key *key,
7371 struct btrfs_key *drop_key) {
7372 if (key->objectid < drop_key->objectid)
7374 else if (key->objectid == drop_key->objectid) {
7375 if (key->type < drop_key->type)
7377 else if (key->type == drop_key->type) {
7378 if (key->offset < drop_key->offset)
7386 * Here are the rules for FULL_BACKREF.
7388 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7389 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7391 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7392 * if it happened after the relocation occurred since we'll have dropped the
7393 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7394 * have no real way to know for sure.
7396 * We process the blocks one root at a time, and we start from the lowest root
7397 * objectid and go to the highest. So we can just lookup the owner backref for
7398 * the record and if we don't find it then we know it doesn't exist and we have
7401 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7402 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7403 * be set or not and then we can check later once we've gathered all the refs.
7405 static int calc_extent_flag(struct btrfs_root *root,
7406 struct cache_tree *extent_cache,
7407 struct extent_buffer *buf,
7408 struct root_item_record *ri,
7411 struct extent_record *rec;
7412 struct cache_extent *cache;
7413 struct tree_backref *tback;
7416 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7417 /* we have added this extent before */
7421 rec = container_of(cache, struct extent_record, cache);
7424 * Except file/reloc tree, we can not have
7427 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7432 if (buf->start == ri->bytenr)
7435 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7438 owner = btrfs_header_owner(buf);
7439 if (owner == ri->objectid)
7442 tback = find_tree_backref(rec, 0, owner);
7447 if (rec->flag_block_full_backref != FLAG_UNSET &&
7448 rec->flag_block_full_backref != 0)
7449 rec->bad_full_backref = 1;
7452 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7453 if (rec->flag_block_full_backref != FLAG_UNSET &&
7454 rec->flag_block_full_backref != 1)
7455 rec->bad_full_backref = 1;
7459 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7461 fprintf(stderr, "Invalid key type(");
7462 print_key_type(stderr, 0, key_type);
7463 fprintf(stderr, ") found in root(");
7464 print_objectid(stderr, rootid, 0);
7465 fprintf(stderr, ")\n");
7469 * Check if the key is valid with its extent buffer.
7471 * This is a early check in case invalid key exists in a extent buffer
7472 * This is not comprehensive yet, but should prevent wrong key/item passed
7475 static int check_type_with_root(u64 rootid, u8 key_type)
7478 /* Only valid in chunk tree */
7479 case BTRFS_DEV_ITEM_KEY:
7480 case BTRFS_CHUNK_ITEM_KEY:
7481 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7484 /* valid in csum and log tree */
7485 case BTRFS_CSUM_TREE_OBJECTID:
7486 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7490 case BTRFS_EXTENT_ITEM_KEY:
7491 case BTRFS_METADATA_ITEM_KEY:
7492 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7493 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7496 case BTRFS_ROOT_ITEM_KEY:
7497 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7500 case BTRFS_DEV_EXTENT_KEY:
7501 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7507 report_mismatch_key_root(key_type, rootid);
7511 static int run_next_block(struct btrfs_root *root,
7512 struct block_info *bits,
7515 struct cache_tree *pending,
7516 struct cache_tree *seen,
7517 struct cache_tree *reada,
7518 struct cache_tree *nodes,
7519 struct cache_tree *extent_cache,
7520 struct cache_tree *chunk_cache,
7521 struct rb_root *dev_cache,
7522 struct block_group_tree *block_group_cache,
7523 struct device_extent_tree *dev_extent_cache,
7524 struct root_item_record *ri)
7526 struct extent_buffer *buf;
7527 struct extent_record *rec = NULL;
7538 struct btrfs_key key;
7539 struct cache_extent *cache;
7542 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7543 bits_nr, &reada_bits);
7548 for(i = 0; i < nritems; i++) {
7549 ret = add_cache_extent(reada, bits[i].start,
7554 /* fixme, get the parent transid */
7555 readahead_tree_block(root, bits[i].start,
7559 *last = bits[0].start;
7560 bytenr = bits[0].start;
7561 size = bits[0].size;
7563 cache = lookup_cache_extent(pending, bytenr, size);
7565 remove_cache_extent(pending, cache);
7568 cache = lookup_cache_extent(reada, bytenr, size);
7570 remove_cache_extent(reada, cache);
7573 cache = lookup_cache_extent(nodes, bytenr, size);
7575 remove_cache_extent(nodes, cache);
7578 cache = lookup_cache_extent(extent_cache, bytenr, size);
7580 rec = container_of(cache, struct extent_record, cache);
7581 gen = rec->parent_generation;
7584 /* fixme, get the real parent transid */
7585 buf = read_tree_block(root, bytenr, size, gen);
7586 if (!extent_buffer_uptodate(buf)) {
7587 record_bad_block_io(root->fs_info,
7588 extent_cache, bytenr, size);
7592 nritems = btrfs_header_nritems(buf);
7595 if (!init_extent_tree) {
7596 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7597 btrfs_header_level(buf), 1, NULL,
7600 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7602 fprintf(stderr, "Couldn't calc extent flags\n");
7603 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7608 ret = calc_extent_flag(root, extent_cache, buf, ri, &flags);
7610 fprintf(stderr, "Couldn't calc extent flags\n");
7611 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7615 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7617 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7618 ri->objectid == btrfs_header_owner(buf)) {
7620 * Ok we got to this block from it's original owner and
7621 * we have FULL_BACKREF set. Relocation can leave
7622 * converted blocks over so this is altogether possible,
7623 * however it's not possible if the generation > the
7624 * last snapshot, so check for this case.
7626 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7627 btrfs_header_generation(buf) > ri->last_snapshot) {
7628 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7629 rec->bad_full_backref = 1;
7634 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7635 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7636 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7637 rec->bad_full_backref = 1;
7641 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7642 rec->flag_block_full_backref = 1;
7646 rec->flag_block_full_backref = 0;
7648 owner = btrfs_header_owner(buf);
7651 ret = check_block(root, extent_cache, buf, flags);
7655 if (btrfs_is_leaf(buf)) {
7656 btree_space_waste += btrfs_leaf_free_space(root, buf);
7657 for (i = 0; i < nritems; i++) {
7658 struct btrfs_file_extent_item *fi;
7659 btrfs_item_key_to_cpu(buf, &key, i);
7661 * Check key type against the leaf owner.
7662 * Could filter quite a lot of early error if
7665 if (check_type_with_root(btrfs_header_owner(buf),
7667 fprintf(stderr, "ignoring invalid key\n");
7670 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7671 process_extent_item(root, extent_cache, buf,
7675 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7676 process_extent_item(root, extent_cache, buf,
7680 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7682 btrfs_item_size_nr(buf, i);
7685 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7686 process_chunk_item(chunk_cache, &key, buf, i);
7689 if (key.type == BTRFS_DEV_ITEM_KEY) {
7690 process_device_item(dev_cache, &key, buf, i);
7693 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7694 process_block_group_item(block_group_cache,
7698 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7699 process_device_extent_item(dev_extent_cache,
7704 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7705 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7706 process_extent_ref_v0(extent_cache, buf, i);
7713 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7714 ret = add_tree_backref(extent_cache,
7715 key.objectid, 0, key.offset, 0);
7717 error("add_tree_backref failed: %s",
7721 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7722 ret = add_tree_backref(extent_cache,
7723 key.objectid, key.offset, 0, 0);
7725 error("add_tree_backref failed: %s",
7729 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7730 struct btrfs_extent_data_ref *ref;
7731 ref = btrfs_item_ptr(buf, i,
7732 struct btrfs_extent_data_ref);
7733 add_data_backref(extent_cache,
7735 btrfs_extent_data_ref_root(buf, ref),
7736 btrfs_extent_data_ref_objectid(buf,
7738 btrfs_extent_data_ref_offset(buf, ref),
7739 btrfs_extent_data_ref_count(buf, ref),
7740 0, root->sectorsize);
7743 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7744 struct btrfs_shared_data_ref *ref;
7745 ref = btrfs_item_ptr(buf, i,
7746 struct btrfs_shared_data_ref);
7747 add_data_backref(extent_cache,
7748 key.objectid, key.offset, 0, 0, 0,
7749 btrfs_shared_data_ref_count(buf, ref),
7750 0, root->sectorsize);
7753 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7754 struct bad_item *bad;
7756 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7760 bad = malloc(sizeof(struct bad_item));
7763 INIT_LIST_HEAD(&bad->list);
7764 memcpy(&bad->key, &key,
7765 sizeof(struct btrfs_key));
7766 bad->root_id = owner;
7767 list_add_tail(&bad->list, &delete_items);
7770 if (key.type != BTRFS_EXTENT_DATA_KEY)
7772 fi = btrfs_item_ptr(buf, i,
7773 struct btrfs_file_extent_item);
7774 if (btrfs_file_extent_type(buf, fi) ==
7775 BTRFS_FILE_EXTENT_INLINE)
7777 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7780 data_bytes_allocated +=
7781 btrfs_file_extent_disk_num_bytes(buf, fi);
7782 if (data_bytes_allocated < root->sectorsize) {
7785 data_bytes_referenced +=
7786 btrfs_file_extent_num_bytes(buf, fi);
7787 add_data_backref(extent_cache,
7788 btrfs_file_extent_disk_bytenr(buf, fi),
7789 parent, owner, key.objectid, key.offset -
7790 btrfs_file_extent_offset(buf, fi), 1, 1,
7791 btrfs_file_extent_disk_num_bytes(buf, fi));
7795 struct btrfs_key first_key;
7797 first_key.objectid = 0;
7800 btrfs_item_key_to_cpu(buf, &first_key, 0);
7801 level = btrfs_header_level(buf);
7802 for (i = 0; i < nritems; i++) {
7803 struct extent_record tmpl;
7805 ptr = btrfs_node_blockptr(buf, i);
7806 size = root->nodesize;
7807 btrfs_node_key_to_cpu(buf, &key, i);
7809 if ((level == ri->drop_level)
7810 && is_dropped_key(&key, &ri->drop_key)) {
7815 memset(&tmpl, 0, sizeof(tmpl));
7816 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7817 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7822 tmpl.max_size = size;
7823 ret = add_extent_rec(extent_cache, &tmpl);
7827 ret = add_tree_backref(extent_cache, ptr, parent,
7830 error("add_tree_backref failed: %s",
7836 add_pending(nodes, seen, ptr, size);
7838 add_pending(pending, seen, ptr, size);
7841 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7842 nritems) * sizeof(struct btrfs_key_ptr);
7844 total_btree_bytes += buf->len;
7845 if (fs_root_objectid(btrfs_header_owner(buf)))
7846 total_fs_tree_bytes += buf->len;
7847 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7848 total_extent_tree_bytes += buf->len;
7849 if (!found_old_backref &&
7850 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7851 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7852 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7853 found_old_backref = 1;
7855 free_extent_buffer(buf);
7859 static int add_root_to_pending(struct extent_buffer *buf,
7860 struct cache_tree *extent_cache,
7861 struct cache_tree *pending,
7862 struct cache_tree *seen,
7863 struct cache_tree *nodes,
7866 struct extent_record tmpl;
7869 if (btrfs_header_level(buf) > 0)
7870 add_pending(nodes, seen, buf->start, buf->len);
7872 add_pending(pending, seen, buf->start, buf->len);
7874 memset(&tmpl, 0, sizeof(tmpl));
7875 tmpl.start = buf->start;
7880 tmpl.max_size = buf->len;
7881 add_extent_rec(extent_cache, &tmpl);
7883 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7884 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7885 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7888 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7893 /* as we fix the tree, we might be deleting blocks that
7894 * we're tracking for repair. This hook makes sure we
7895 * remove any backrefs for blocks as we are fixing them.
7897 static int free_extent_hook(struct btrfs_trans_handle *trans,
7898 struct btrfs_root *root,
7899 u64 bytenr, u64 num_bytes, u64 parent,
7900 u64 root_objectid, u64 owner, u64 offset,
7903 struct extent_record *rec;
7904 struct cache_extent *cache;
7906 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
7908 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
7909 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
7913 rec = container_of(cache, struct extent_record, cache);
7915 struct data_backref *back;
7916 back = find_data_backref(rec, parent, root_objectid, owner,
7917 offset, 1, bytenr, num_bytes);
7920 if (back->node.found_ref) {
7921 back->found_ref -= refs_to_drop;
7923 rec->refs -= refs_to_drop;
7925 if (back->node.found_extent_tree) {
7926 back->num_refs -= refs_to_drop;
7927 if (rec->extent_item_refs)
7928 rec->extent_item_refs -= refs_to_drop;
7930 if (back->found_ref == 0)
7931 back->node.found_ref = 0;
7932 if (back->num_refs == 0)
7933 back->node.found_extent_tree = 0;
7935 if (!back->node.found_extent_tree && back->node.found_ref) {
7936 list_del(&back->node.list);
7940 struct tree_backref *back;
7941 back = find_tree_backref(rec, parent, root_objectid);
7944 if (back->node.found_ref) {
7947 back->node.found_ref = 0;
7949 if (back->node.found_extent_tree) {
7950 if (rec->extent_item_refs)
7951 rec->extent_item_refs--;
7952 back->node.found_extent_tree = 0;
7954 if (!back->node.found_extent_tree && back->node.found_ref) {
7955 list_del(&back->node.list);
7959 maybe_free_extent_rec(extent_cache, rec);
7964 static int delete_extent_records(struct btrfs_trans_handle *trans,
7965 struct btrfs_root *root,
7966 struct btrfs_path *path,
7969 struct btrfs_key key;
7970 struct btrfs_key found_key;
7971 struct extent_buffer *leaf;
7976 key.objectid = bytenr;
7978 key.offset = (u64)-1;
7981 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
7988 if (path->slots[0] == 0)
7994 leaf = path->nodes[0];
7995 slot = path->slots[0];
7997 btrfs_item_key_to_cpu(leaf, &found_key, slot);
7998 if (found_key.objectid != bytenr)
8001 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
8002 found_key.type != BTRFS_METADATA_ITEM_KEY &&
8003 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
8004 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
8005 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
8006 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
8007 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
8008 btrfs_release_path(path);
8009 if (found_key.type == 0) {
8010 if (found_key.offset == 0)
8012 key.offset = found_key.offset - 1;
8013 key.type = found_key.type;
8015 key.type = found_key.type - 1;
8016 key.offset = (u64)-1;
8020 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8021 found_key.objectid, found_key.type, found_key.offset);
8023 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8026 btrfs_release_path(path);
8028 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8029 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8030 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8031 found_key.offset : root->nodesize;
8033 ret = btrfs_update_block_group(trans, root, bytenr,
8040 btrfs_release_path(path);
8045 * for a single backref, this will allocate a new extent
8046 * and add the backref to it.
8048 static int record_extent(struct btrfs_trans_handle *trans,
8049 struct btrfs_fs_info *info,
8050 struct btrfs_path *path,
8051 struct extent_record *rec,
8052 struct extent_backref *back,
8053 int allocated, u64 flags)
8056 struct btrfs_root *extent_root = info->extent_root;
8057 struct extent_buffer *leaf;
8058 struct btrfs_key ins_key;
8059 struct btrfs_extent_item *ei;
8060 struct data_backref *dback;
8061 struct btrfs_tree_block_info *bi;
8064 rec->max_size = max_t(u64, rec->max_size,
8065 info->extent_root->nodesize);
8068 u32 item_size = sizeof(*ei);
8071 item_size += sizeof(*bi);
8073 ins_key.objectid = rec->start;
8074 ins_key.offset = rec->max_size;
8075 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8077 ret = btrfs_insert_empty_item(trans, extent_root, path,
8078 &ins_key, item_size);
8082 leaf = path->nodes[0];
8083 ei = btrfs_item_ptr(leaf, path->slots[0],
8084 struct btrfs_extent_item);
8086 btrfs_set_extent_refs(leaf, ei, 0);
8087 btrfs_set_extent_generation(leaf, ei, rec->generation);
8089 if (back->is_data) {
8090 btrfs_set_extent_flags(leaf, ei,
8091 BTRFS_EXTENT_FLAG_DATA);
8093 struct btrfs_disk_key copy_key;;
8095 bi = (struct btrfs_tree_block_info *)(ei + 1);
8096 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8099 btrfs_set_disk_key_objectid(©_key,
8100 rec->info_objectid);
8101 btrfs_set_disk_key_type(©_key, 0);
8102 btrfs_set_disk_key_offset(©_key, 0);
8104 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8105 btrfs_set_tree_block_key(leaf, bi, ©_key);
8107 btrfs_set_extent_flags(leaf, ei,
8108 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8111 btrfs_mark_buffer_dirty(leaf);
8112 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8113 rec->max_size, 1, 0);
8116 btrfs_release_path(path);
8119 if (back->is_data) {
8123 dback = to_data_backref(back);
8124 if (back->full_backref)
8125 parent = dback->parent;
8129 for (i = 0; i < dback->found_ref; i++) {
8130 /* if parent != 0, we're doing a full backref
8131 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8132 * just makes the backref allocator create a data
8135 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8136 rec->start, rec->max_size,
8140 BTRFS_FIRST_FREE_OBJECTID :
8146 fprintf(stderr, "adding new data backref"
8147 " on %llu %s %llu owner %llu"
8148 " offset %llu found %d\n",
8149 (unsigned long long)rec->start,
8150 back->full_backref ?
8152 back->full_backref ?
8153 (unsigned long long)parent :
8154 (unsigned long long)dback->root,
8155 (unsigned long long)dback->owner,
8156 (unsigned long long)dback->offset,
8160 struct tree_backref *tback;
8162 tback = to_tree_backref(back);
8163 if (back->full_backref)
8164 parent = tback->parent;
8168 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8169 rec->start, rec->max_size,
8170 parent, tback->root, 0, 0);
8171 fprintf(stderr, "adding new tree backref on "
8172 "start %llu len %llu parent %llu root %llu\n",
8173 rec->start, rec->max_size, parent, tback->root);
8176 btrfs_release_path(path);
8180 static struct extent_entry *find_entry(struct list_head *entries,
8181 u64 bytenr, u64 bytes)
8183 struct extent_entry *entry = NULL;
8185 list_for_each_entry(entry, entries, list) {
8186 if (entry->bytenr == bytenr && entry->bytes == bytes)
8193 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8195 struct extent_entry *entry, *best = NULL, *prev = NULL;
8197 list_for_each_entry(entry, entries, list) {
8199 * If there are as many broken entries as entries then we know
8200 * not to trust this particular entry.
8202 if (entry->broken == entry->count)
8206 * Special case, when there are only two entries and 'best' is
8216 * If our current entry == best then we can't be sure our best
8217 * is really the best, so we need to keep searching.
8219 if (best && best->count == entry->count) {
8225 /* Prev == entry, not good enough, have to keep searching */
8226 if (!prev->broken && prev->count == entry->count)
8230 best = (prev->count > entry->count) ? prev : entry;
8231 else if (best->count < entry->count)
8239 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8240 struct data_backref *dback, struct extent_entry *entry)
8242 struct btrfs_trans_handle *trans;
8243 struct btrfs_root *root;
8244 struct btrfs_file_extent_item *fi;
8245 struct extent_buffer *leaf;
8246 struct btrfs_key key;
8250 key.objectid = dback->root;
8251 key.type = BTRFS_ROOT_ITEM_KEY;
8252 key.offset = (u64)-1;
8253 root = btrfs_read_fs_root(info, &key);
8255 fprintf(stderr, "Couldn't find root for our ref\n");
8260 * The backref points to the original offset of the extent if it was
8261 * split, so we need to search down to the offset we have and then walk
8262 * forward until we find the backref we're looking for.
8264 key.objectid = dback->owner;
8265 key.type = BTRFS_EXTENT_DATA_KEY;
8266 key.offset = dback->offset;
8267 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8269 fprintf(stderr, "Error looking up ref %d\n", ret);
8274 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8275 ret = btrfs_next_leaf(root, path);
8277 fprintf(stderr, "Couldn't find our ref, next\n");
8281 leaf = path->nodes[0];
8282 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8283 if (key.objectid != dback->owner ||
8284 key.type != BTRFS_EXTENT_DATA_KEY) {
8285 fprintf(stderr, "Couldn't find our ref, search\n");
8288 fi = btrfs_item_ptr(leaf, path->slots[0],
8289 struct btrfs_file_extent_item);
8290 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8291 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8293 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8298 btrfs_release_path(path);
8300 trans = btrfs_start_transaction(root, 1);
8302 return PTR_ERR(trans);
8305 * Ok we have the key of the file extent we want to fix, now we can cow
8306 * down to the thing and fix it.
8308 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8310 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8311 key.objectid, key.type, key.offset, ret);
8315 fprintf(stderr, "Well that's odd, we just found this key "
8316 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8321 leaf = path->nodes[0];
8322 fi = btrfs_item_ptr(leaf, path->slots[0],
8323 struct btrfs_file_extent_item);
8325 if (btrfs_file_extent_compression(leaf, fi) &&
8326 dback->disk_bytenr != entry->bytenr) {
8327 fprintf(stderr, "Ref doesn't match the record start and is "
8328 "compressed, please take a btrfs-image of this file "
8329 "system and send it to a btrfs developer so they can "
8330 "complete this functionality for bytenr %Lu\n",
8331 dback->disk_bytenr);
8336 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8337 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8338 } else if (dback->disk_bytenr > entry->bytenr) {
8339 u64 off_diff, offset;
8341 off_diff = dback->disk_bytenr - entry->bytenr;
8342 offset = btrfs_file_extent_offset(leaf, fi);
8343 if (dback->disk_bytenr + offset +
8344 btrfs_file_extent_num_bytes(leaf, fi) >
8345 entry->bytenr + entry->bytes) {
8346 fprintf(stderr, "Ref is past the entry end, please "
8347 "take a btrfs-image of this file system and "
8348 "send it to a btrfs developer, ref %Lu\n",
8349 dback->disk_bytenr);
8354 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8355 btrfs_set_file_extent_offset(leaf, fi, offset);
8356 } else if (dback->disk_bytenr < entry->bytenr) {
8359 offset = btrfs_file_extent_offset(leaf, fi);
8360 if (dback->disk_bytenr + offset < entry->bytenr) {
8361 fprintf(stderr, "Ref is before the entry start, please"
8362 " take a btrfs-image of this file system and "
8363 "send it to a btrfs developer, ref %Lu\n",
8364 dback->disk_bytenr);
8369 offset += dback->disk_bytenr;
8370 offset -= entry->bytenr;
8371 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8372 btrfs_set_file_extent_offset(leaf, fi, offset);
8375 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8378 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8379 * only do this if we aren't using compression, otherwise it's a
8382 if (!btrfs_file_extent_compression(leaf, fi))
8383 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8385 printf("ram bytes may be wrong?\n");
8386 btrfs_mark_buffer_dirty(leaf);
8388 err = btrfs_commit_transaction(trans, root);
8389 btrfs_release_path(path);
8390 return ret ? ret : err;
8393 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8394 struct extent_record *rec)
8396 struct extent_backref *back;
8397 struct data_backref *dback;
8398 struct extent_entry *entry, *best = NULL;
8401 int broken_entries = 0;
8406 * Metadata is easy and the backrefs should always agree on bytenr and
8407 * size, if not we've got bigger issues.
8412 list_for_each_entry(back, &rec->backrefs, list) {
8413 if (back->full_backref || !back->is_data)
8416 dback = to_data_backref(back);
8419 * We only pay attention to backrefs that we found a real
8422 if (dback->found_ref == 0)
8426 * For now we only catch when the bytes don't match, not the
8427 * bytenr. We can easily do this at the same time, but I want
8428 * to have a fs image to test on before we just add repair
8429 * functionality willy-nilly so we know we won't screw up the
8433 entry = find_entry(&entries, dback->disk_bytenr,
8436 entry = malloc(sizeof(struct extent_entry));
8441 memset(entry, 0, sizeof(*entry));
8442 entry->bytenr = dback->disk_bytenr;
8443 entry->bytes = dback->bytes;
8444 list_add_tail(&entry->list, &entries);
8449 * If we only have on entry we may think the entries agree when
8450 * in reality they don't so we have to do some extra checking.
8452 if (dback->disk_bytenr != rec->start ||
8453 dback->bytes != rec->nr || back->broken)
8464 /* Yay all the backrefs agree, carry on good sir */
8465 if (nr_entries <= 1 && !mismatch)
8468 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8469 "%Lu\n", rec->start);
8472 * First we want to see if the backrefs can agree amongst themselves who
8473 * is right, so figure out which one of the entries has the highest
8476 best = find_most_right_entry(&entries);
8479 * Ok so we may have an even split between what the backrefs think, so
8480 * this is where we use the extent ref to see what it thinks.
8483 entry = find_entry(&entries, rec->start, rec->nr);
8484 if (!entry && (!broken_entries || !rec->found_rec)) {
8485 fprintf(stderr, "Backrefs don't agree with each other "
8486 "and extent record doesn't agree with anybody,"
8487 " so we can't fix bytenr %Lu bytes %Lu\n",
8488 rec->start, rec->nr);
8491 } else if (!entry) {
8493 * Ok our backrefs were broken, we'll assume this is the
8494 * correct value and add an entry for this range.
8496 entry = malloc(sizeof(struct extent_entry));
8501 memset(entry, 0, sizeof(*entry));
8502 entry->bytenr = rec->start;
8503 entry->bytes = rec->nr;
8504 list_add_tail(&entry->list, &entries);
8508 best = find_most_right_entry(&entries);
8510 fprintf(stderr, "Backrefs and extent record evenly "
8511 "split on who is right, this is going to "
8512 "require user input to fix bytenr %Lu bytes "
8513 "%Lu\n", rec->start, rec->nr);
8520 * I don't think this can happen currently as we'll abort() if we catch
8521 * this case higher up, but in case somebody removes that we still can't
8522 * deal with it properly here yet, so just bail out of that's the case.
8524 if (best->bytenr != rec->start) {
8525 fprintf(stderr, "Extent start and backref starts don't match, "
8526 "please use btrfs-image on this file system and send "
8527 "it to a btrfs developer so they can make fsck fix "
8528 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8529 rec->start, rec->nr);
8535 * Ok great we all agreed on an extent record, let's go find the real
8536 * references and fix up the ones that don't match.
8538 list_for_each_entry(back, &rec->backrefs, list) {
8539 if (back->full_backref || !back->is_data)
8542 dback = to_data_backref(back);
8545 * Still ignoring backrefs that don't have a real ref attached
8548 if (dback->found_ref == 0)
8551 if (dback->bytes == best->bytes &&
8552 dback->disk_bytenr == best->bytenr)
8555 ret = repair_ref(info, path, dback, best);
8561 * Ok we messed with the actual refs, which means we need to drop our
8562 * entire cache and go back and rescan. I know this is a huge pain and
8563 * adds a lot of extra work, but it's the only way to be safe. Once all
8564 * the backrefs agree we may not need to do anything to the extent
8569 while (!list_empty(&entries)) {
8570 entry = list_entry(entries.next, struct extent_entry, list);
8571 list_del_init(&entry->list);
8577 static int process_duplicates(struct btrfs_root *root,
8578 struct cache_tree *extent_cache,
8579 struct extent_record *rec)
8581 struct extent_record *good, *tmp;
8582 struct cache_extent *cache;
8586 * If we found a extent record for this extent then return, or if we
8587 * have more than one duplicate we are likely going to need to delete
8590 if (rec->found_rec || rec->num_duplicates > 1)
8593 /* Shouldn't happen but just in case */
8594 BUG_ON(!rec->num_duplicates);
8597 * So this happens if we end up with a backref that doesn't match the
8598 * actual extent entry. So either the backref is bad or the extent
8599 * entry is bad. Either way we want to have the extent_record actually
8600 * reflect what we found in the extent_tree, so we need to take the
8601 * duplicate out and use that as the extent_record since the only way we
8602 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8604 remove_cache_extent(extent_cache, &rec->cache);
8606 good = to_extent_record(rec->dups.next);
8607 list_del_init(&good->list);
8608 INIT_LIST_HEAD(&good->backrefs);
8609 INIT_LIST_HEAD(&good->dups);
8610 good->cache.start = good->start;
8611 good->cache.size = good->nr;
8612 good->content_checked = 0;
8613 good->owner_ref_checked = 0;
8614 good->num_duplicates = 0;
8615 good->refs = rec->refs;
8616 list_splice_init(&rec->backrefs, &good->backrefs);
8618 cache = lookup_cache_extent(extent_cache, good->start,
8622 tmp = container_of(cache, struct extent_record, cache);
8625 * If we find another overlapping extent and it's found_rec is
8626 * set then it's a duplicate and we need to try and delete
8629 if (tmp->found_rec || tmp->num_duplicates > 0) {
8630 if (list_empty(&good->list))
8631 list_add_tail(&good->list,
8632 &duplicate_extents);
8633 good->num_duplicates += tmp->num_duplicates + 1;
8634 list_splice_init(&tmp->dups, &good->dups);
8635 list_del_init(&tmp->list);
8636 list_add_tail(&tmp->list, &good->dups);
8637 remove_cache_extent(extent_cache, &tmp->cache);
8642 * Ok we have another non extent item backed extent rec, so lets
8643 * just add it to this extent and carry on like we did above.
8645 good->refs += tmp->refs;
8646 list_splice_init(&tmp->backrefs, &good->backrefs);
8647 remove_cache_extent(extent_cache, &tmp->cache);
8650 ret = insert_cache_extent(extent_cache, &good->cache);
8653 return good->num_duplicates ? 0 : 1;
8656 static int delete_duplicate_records(struct btrfs_root *root,
8657 struct extent_record *rec)
8659 struct btrfs_trans_handle *trans;
8660 LIST_HEAD(delete_list);
8661 struct btrfs_path path;
8662 struct extent_record *tmp, *good, *n;
8665 struct btrfs_key key;
8667 btrfs_init_path(&path);
8670 /* Find the record that covers all of the duplicates. */
8671 list_for_each_entry(tmp, &rec->dups, list) {
8672 if (good->start < tmp->start)
8674 if (good->nr > tmp->nr)
8677 if (tmp->start + tmp->nr < good->start + good->nr) {
8678 fprintf(stderr, "Ok we have overlapping extents that "
8679 "aren't completely covered by each other, this "
8680 "is going to require more careful thought. "
8681 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8682 tmp->start, tmp->nr, good->start, good->nr);
8689 list_add_tail(&rec->list, &delete_list);
8691 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8694 list_move_tail(&tmp->list, &delete_list);
8697 root = root->fs_info->extent_root;
8698 trans = btrfs_start_transaction(root, 1);
8699 if (IS_ERR(trans)) {
8700 ret = PTR_ERR(trans);
8704 list_for_each_entry(tmp, &delete_list, list) {
8705 if (tmp->found_rec == 0)
8707 key.objectid = tmp->start;
8708 key.type = BTRFS_EXTENT_ITEM_KEY;
8709 key.offset = tmp->nr;
8711 /* Shouldn't happen but just in case */
8712 if (tmp->metadata) {
8713 fprintf(stderr, "Well this shouldn't happen, extent "
8714 "record overlaps but is metadata? "
8715 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8719 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8725 ret = btrfs_del_item(trans, root, &path);
8728 btrfs_release_path(&path);
8731 err = btrfs_commit_transaction(trans, root);
8735 while (!list_empty(&delete_list)) {
8736 tmp = to_extent_record(delete_list.next);
8737 list_del_init(&tmp->list);
8743 while (!list_empty(&rec->dups)) {
8744 tmp = to_extent_record(rec->dups.next);
8745 list_del_init(&tmp->list);
8749 btrfs_release_path(&path);
8751 if (!ret && !nr_del)
8752 rec->num_duplicates = 0;
8754 return ret ? ret : nr_del;
8757 static int find_possible_backrefs(struct btrfs_fs_info *info,
8758 struct btrfs_path *path,
8759 struct cache_tree *extent_cache,
8760 struct extent_record *rec)
8762 struct btrfs_root *root;
8763 struct extent_backref *back;
8764 struct data_backref *dback;
8765 struct cache_extent *cache;
8766 struct btrfs_file_extent_item *fi;
8767 struct btrfs_key key;
8771 list_for_each_entry(back, &rec->backrefs, list) {
8772 /* Don't care about full backrefs (poor unloved backrefs) */
8773 if (back->full_backref || !back->is_data)
8776 dback = to_data_backref(back);
8778 /* We found this one, we don't need to do a lookup */
8779 if (dback->found_ref)
8782 key.objectid = dback->root;
8783 key.type = BTRFS_ROOT_ITEM_KEY;
8784 key.offset = (u64)-1;
8786 root = btrfs_read_fs_root(info, &key);
8788 /* No root, definitely a bad ref, skip */
8789 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8791 /* Other err, exit */
8793 return PTR_ERR(root);
8795 key.objectid = dback->owner;
8796 key.type = BTRFS_EXTENT_DATA_KEY;
8797 key.offset = dback->offset;
8798 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8800 btrfs_release_path(path);
8803 /* Didn't find it, we can carry on */
8808 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8809 struct btrfs_file_extent_item);
8810 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8811 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8812 btrfs_release_path(path);
8813 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8815 struct extent_record *tmp;
8816 tmp = container_of(cache, struct extent_record, cache);
8819 * If we found an extent record for the bytenr for this
8820 * particular backref then we can't add it to our
8821 * current extent record. We only want to add backrefs
8822 * that don't have a corresponding extent item in the
8823 * extent tree since they likely belong to this record
8824 * and we need to fix it if it doesn't match bytenrs.
8830 dback->found_ref += 1;
8831 dback->disk_bytenr = bytenr;
8832 dback->bytes = bytes;
8835 * Set this so the verify backref code knows not to trust the
8836 * values in this backref.
8845 * Record orphan data ref into corresponding root.
8847 * Return 0 if the extent item contains data ref and recorded.
8848 * Return 1 if the extent item contains no useful data ref
8849 * On that case, it may contains only shared_dataref or metadata backref
8850 * or the file extent exists(this should be handled by the extent bytenr
8852 * Return <0 if something goes wrong.
8854 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8855 struct extent_record *rec)
8857 struct btrfs_key key;
8858 struct btrfs_root *dest_root;
8859 struct extent_backref *back;
8860 struct data_backref *dback;
8861 struct orphan_data_extent *orphan;
8862 struct btrfs_path path;
8863 int recorded_data_ref = 0;
8868 btrfs_init_path(&path);
8869 list_for_each_entry(back, &rec->backrefs, list) {
8870 if (back->full_backref || !back->is_data ||
8871 !back->found_extent_tree)
8873 dback = to_data_backref(back);
8874 if (dback->found_ref)
8876 key.objectid = dback->root;
8877 key.type = BTRFS_ROOT_ITEM_KEY;
8878 key.offset = (u64)-1;
8880 dest_root = btrfs_read_fs_root(fs_info, &key);
8882 /* For non-exist root we just skip it */
8883 if (IS_ERR(dest_root) || !dest_root)
8886 key.objectid = dback->owner;
8887 key.type = BTRFS_EXTENT_DATA_KEY;
8888 key.offset = dback->offset;
8890 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8891 btrfs_release_path(&path);
8893 * For ret < 0, it's OK since the fs-tree may be corrupted,
8894 * we need to record it for inode/file extent rebuild.
8895 * For ret > 0, we record it only for file extent rebuild.
8896 * For ret == 0, the file extent exists but only bytenr
8897 * mismatch, let the original bytenr fix routine to handle,
8903 orphan = malloc(sizeof(*orphan));
8908 INIT_LIST_HEAD(&orphan->list);
8909 orphan->root = dback->root;
8910 orphan->objectid = dback->owner;
8911 orphan->offset = dback->offset;
8912 orphan->disk_bytenr = rec->cache.start;
8913 orphan->disk_len = rec->cache.size;
8914 list_add(&dest_root->orphan_data_extents, &orphan->list);
8915 recorded_data_ref = 1;
8918 btrfs_release_path(&path);
8920 return !recorded_data_ref;
8926 * when an incorrect extent item is found, this will delete
8927 * all of the existing entries for it and recreate them
8928 * based on what the tree scan found.
8930 static int fixup_extent_refs(struct btrfs_fs_info *info,
8931 struct cache_tree *extent_cache,
8932 struct extent_record *rec)
8934 struct btrfs_trans_handle *trans = NULL;
8936 struct btrfs_path path;
8937 struct list_head *cur = rec->backrefs.next;
8938 struct cache_extent *cache;
8939 struct extent_backref *back;
8943 if (rec->flag_block_full_backref)
8944 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
8946 btrfs_init_path(&path);
8947 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
8949 * Sometimes the backrefs themselves are so broken they don't
8950 * get attached to any meaningful rec, so first go back and
8951 * check any of our backrefs that we couldn't find and throw
8952 * them into the list if we find the backref so that
8953 * verify_backrefs can figure out what to do.
8955 ret = find_possible_backrefs(info, &path, extent_cache, rec);
8960 /* step one, make sure all of the backrefs agree */
8961 ret = verify_backrefs(info, &path, rec);
8965 trans = btrfs_start_transaction(info->extent_root, 1);
8966 if (IS_ERR(trans)) {
8967 ret = PTR_ERR(trans);
8971 /* step two, delete all the existing records */
8972 ret = delete_extent_records(trans, info->extent_root, &path,
8978 /* was this block corrupt? If so, don't add references to it */
8979 cache = lookup_cache_extent(info->corrupt_blocks,
8980 rec->start, rec->max_size);
8986 /* step three, recreate all the refs we did find */
8987 while(cur != &rec->backrefs) {
8988 back = to_extent_backref(cur);
8992 * if we didn't find any references, don't create a
8995 if (!back->found_ref)
8998 rec->bad_full_backref = 0;
8999 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
9007 int err = btrfs_commit_transaction(trans, info->extent_root);
9013 fprintf(stderr, "Repaired extent references for %llu\n",
9014 (unsigned long long)rec->start);
9016 btrfs_release_path(&path);
9020 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9021 struct extent_record *rec)
9023 struct btrfs_trans_handle *trans;
9024 struct btrfs_root *root = fs_info->extent_root;
9025 struct btrfs_path path;
9026 struct btrfs_extent_item *ei;
9027 struct btrfs_key key;
9031 key.objectid = rec->start;
9032 if (rec->metadata) {
9033 key.type = BTRFS_METADATA_ITEM_KEY;
9034 key.offset = rec->info_level;
9036 key.type = BTRFS_EXTENT_ITEM_KEY;
9037 key.offset = rec->max_size;
9040 trans = btrfs_start_transaction(root, 0);
9042 return PTR_ERR(trans);
9044 btrfs_init_path(&path);
9045 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9047 btrfs_release_path(&path);
9048 btrfs_commit_transaction(trans, root);
9051 fprintf(stderr, "Didn't find extent for %llu\n",
9052 (unsigned long long)rec->start);
9053 btrfs_release_path(&path);
9054 btrfs_commit_transaction(trans, root);
9058 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9059 struct btrfs_extent_item);
9060 flags = btrfs_extent_flags(path.nodes[0], ei);
9061 if (rec->flag_block_full_backref) {
9062 fprintf(stderr, "setting full backref on %llu\n",
9063 (unsigned long long)key.objectid);
9064 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9066 fprintf(stderr, "clearing full backref on %llu\n",
9067 (unsigned long long)key.objectid);
9068 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9070 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9071 btrfs_mark_buffer_dirty(path.nodes[0]);
9072 btrfs_release_path(&path);
9073 ret = btrfs_commit_transaction(trans, root);
9075 fprintf(stderr, "Repaired extent flags for %llu\n",
9076 (unsigned long long)rec->start);
9081 /* right now we only prune from the extent allocation tree */
9082 static int prune_one_block(struct btrfs_trans_handle *trans,
9083 struct btrfs_fs_info *info,
9084 struct btrfs_corrupt_block *corrupt)
9087 struct btrfs_path path;
9088 struct extent_buffer *eb;
9092 int level = corrupt->level + 1;
9094 btrfs_init_path(&path);
9096 /* we want to stop at the parent to our busted block */
9097 path.lowest_level = level;
9099 ret = btrfs_search_slot(trans, info->extent_root,
9100 &corrupt->key, &path, -1, 1);
9105 eb = path.nodes[level];
9112 * hopefully the search gave us the block we want to prune,
9113 * lets try that first
9115 slot = path.slots[level];
9116 found = btrfs_node_blockptr(eb, slot);
9117 if (found == corrupt->cache.start)
9120 nritems = btrfs_header_nritems(eb);
9122 /* the search failed, lets scan this node and hope we find it */
9123 for (slot = 0; slot < nritems; slot++) {
9124 found = btrfs_node_blockptr(eb, slot);
9125 if (found == corrupt->cache.start)
9129 * we couldn't find the bad block. TODO, search all the nodes for pointers
9132 if (eb == info->extent_root->node) {
9137 btrfs_release_path(&path);
9142 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9143 ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
9146 btrfs_release_path(&path);
9150 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9152 struct btrfs_trans_handle *trans = NULL;
9153 struct cache_extent *cache;
9154 struct btrfs_corrupt_block *corrupt;
9157 cache = search_cache_extent(info->corrupt_blocks, 0);
9161 trans = btrfs_start_transaction(info->extent_root, 1);
9163 return PTR_ERR(trans);
9165 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9166 prune_one_block(trans, info, corrupt);
9167 remove_cache_extent(info->corrupt_blocks, cache);
9170 return btrfs_commit_transaction(trans, info->extent_root);
9174 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9176 struct btrfs_block_group_cache *cache;
9181 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9182 &start, &end, EXTENT_DIRTY);
9185 clear_extent_dirty(&fs_info->free_space_cache, start, end);
9190 cache = btrfs_lookup_first_block_group(fs_info, start);
9195 start = cache->key.objectid + cache->key.offset;
9199 static int check_extent_refs(struct btrfs_root *root,
9200 struct cache_tree *extent_cache)
9202 struct extent_record *rec;
9203 struct cache_extent *cache;
9209 * if we're doing a repair, we have to make sure
9210 * we don't allocate from the problem extents.
9211 * In the worst case, this will be all the
9214 cache = search_cache_extent(extent_cache, 0);
9216 rec = container_of(cache, struct extent_record, cache);
9217 set_extent_dirty(root->fs_info->excluded_extents,
9219 rec->start + rec->max_size - 1);
9220 cache = next_cache_extent(cache);
9223 /* pin down all the corrupted blocks too */
9224 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9226 set_extent_dirty(root->fs_info->excluded_extents,
9228 cache->start + cache->size - 1);
9229 cache = next_cache_extent(cache);
9231 prune_corrupt_blocks(root->fs_info);
9232 reset_cached_block_groups(root->fs_info);
9235 reset_cached_block_groups(root->fs_info);
9238 * We need to delete any duplicate entries we find first otherwise we
9239 * could mess up the extent tree when we have backrefs that actually
9240 * belong to a different extent item and not the weird duplicate one.
9242 while (repair && !list_empty(&duplicate_extents)) {
9243 rec = to_extent_record(duplicate_extents.next);
9244 list_del_init(&rec->list);
9246 /* Sometimes we can find a backref before we find an actual
9247 * extent, so we need to process it a little bit to see if there
9248 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9249 * if this is a backref screwup. If we need to delete stuff
9250 * process_duplicates() will return 0, otherwise it will return
9253 if (process_duplicates(root, extent_cache, rec))
9255 ret = delete_duplicate_records(root, rec);
9259 * delete_duplicate_records will return the number of entries
9260 * deleted, so if it's greater than 0 then we know we actually
9261 * did something and we need to remove.
9274 cache = search_cache_extent(extent_cache, 0);
9277 rec = container_of(cache, struct extent_record, cache);
9278 if (rec->num_duplicates) {
9279 fprintf(stderr, "extent item %llu has multiple extent "
9280 "items\n", (unsigned long long)rec->start);
9284 if (rec->refs != rec->extent_item_refs) {
9285 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9286 (unsigned long long)rec->start,
9287 (unsigned long long)rec->nr);
9288 fprintf(stderr, "extent item %llu, found %llu\n",
9289 (unsigned long long)rec->extent_item_refs,
9290 (unsigned long long)rec->refs);
9291 ret = record_orphan_data_extents(root->fs_info, rec);
9297 if (all_backpointers_checked(rec, 1)) {
9298 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9299 (unsigned long long)rec->start,
9300 (unsigned long long)rec->nr);
9304 if (!rec->owner_ref_checked) {
9305 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9306 (unsigned long long)rec->start,
9307 (unsigned long long)rec->nr);
9312 if (repair && fix) {
9313 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9319 if (rec->bad_full_backref) {
9320 fprintf(stderr, "bad full backref, on [%llu]\n",
9321 (unsigned long long)rec->start);
9323 ret = fixup_extent_flags(root->fs_info, rec);
9331 * Although it's not a extent ref's problem, we reuse this
9332 * routine for error reporting.
9333 * No repair function yet.
9335 if (rec->crossing_stripes) {
9337 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9338 rec->start, rec->start + rec->max_size);
9342 if (rec->wrong_chunk_type) {
9344 "bad extent [%llu, %llu), type mismatch with chunk\n",
9345 rec->start, rec->start + rec->max_size);
9349 remove_cache_extent(extent_cache, cache);
9350 free_all_extent_backrefs(rec);
9351 if (!init_extent_tree && repair && (!cur_err || fix))
9352 clear_extent_dirty(root->fs_info->excluded_extents,
9354 rec->start + rec->max_size - 1);
9359 if (ret && ret != -EAGAIN) {
9360 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9363 struct btrfs_trans_handle *trans;
9365 root = root->fs_info->extent_root;
9366 trans = btrfs_start_transaction(root, 1);
9367 if (IS_ERR(trans)) {
9368 ret = PTR_ERR(trans);
9372 btrfs_fix_block_accounting(trans, root);
9373 ret = btrfs_commit_transaction(trans, root);
9382 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9386 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9387 stripe_size = length;
9388 stripe_size /= num_stripes;
9389 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9390 stripe_size = length * 2;
9391 stripe_size /= num_stripes;
9392 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9393 stripe_size = length;
9394 stripe_size /= (num_stripes - 1);
9395 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9396 stripe_size = length;
9397 stripe_size /= (num_stripes - 2);
9399 stripe_size = length;
9405 * Check the chunk with its block group/dev list ref:
9406 * Return 0 if all refs seems valid.
9407 * Return 1 if part of refs seems valid, need later check for rebuild ref
9408 * like missing block group and needs to search extent tree to rebuild them.
9409 * Return -1 if essential refs are missing and unable to rebuild.
9411 static int check_chunk_refs(struct chunk_record *chunk_rec,
9412 struct block_group_tree *block_group_cache,
9413 struct device_extent_tree *dev_extent_cache,
9416 struct cache_extent *block_group_item;
9417 struct block_group_record *block_group_rec;
9418 struct cache_extent *dev_extent_item;
9419 struct device_extent_record *dev_extent_rec;
9423 int metadump_v2 = 0;
9427 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9430 if (block_group_item) {
9431 block_group_rec = container_of(block_group_item,
9432 struct block_group_record,
9434 if (chunk_rec->length != block_group_rec->offset ||
9435 chunk_rec->offset != block_group_rec->objectid ||
9437 chunk_rec->type_flags != block_group_rec->flags)) {
9440 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9441 chunk_rec->objectid,
9446 chunk_rec->type_flags,
9447 block_group_rec->objectid,
9448 block_group_rec->type,
9449 block_group_rec->offset,
9450 block_group_rec->offset,
9451 block_group_rec->objectid,
9452 block_group_rec->flags);
9455 list_del_init(&block_group_rec->list);
9456 chunk_rec->bg_rec = block_group_rec;
9461 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9462 chunk_rec->objectid,
9467 chunk_rec->type_flags);
9474 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9475 chunk_rec->num_stripes);
9476 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9477 devid = chunk_rec->stripes[i].devid;
9478 offset = chunk_rec->stripes[i].offset;
9479 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9480 devid, offset, length);
9481 if (dev_extent_item) {
9482 dev_extent_rec = container_of(dev_extent_item,
9483 struct device_extent_record,
9485 if (dev_extent_rec->objectid != devid ||
9486 dev_extent_rec->offset != offset ||
9487 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9488 dev_extent_rec->length != length) {
9491 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9492 chunk_rec->objectid,
9495 chunk_rec->stripes[i].devid,
9496 chunk_rec->stripes[i].offset,
9497 dev_extent_rec->objectid,
9498 dev_extent_rec->offset,
9499 dev_extent_rec->length);
9502 list_move(&dev_extent_rec->chunk_list,
9503 &chunk_rec->dextents);
9508 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9509 chunk_rec->objectid,
9512 chunk_rec->stripes[i].devid,
9513 chunk_rec->stripes[i].offset);
9520 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9521 int check_chunks(struct cache_tree *chunk_cache,
9522 struct block_group_tree *block_group_cache,
9523 struct device_extent_tree *dev_extent_cache,
9524 struct list_head *good, struct list_head *bad,
9525 struct list_head *rebuild, int silent)
9527 struct cache_extent *chunk_item;
9528 struct chunk_record *chunk_rec;
9529 struct block_group_record *bg_rec;
9530 struct device_extent_record *dext_rec;
9534 chunk_item = first_cache_extent(chunk_cache);
9535 while (chunk_item) {
9536 chunk_rec = container_of(chunk_item, struct chunk_record,
9538 err = check_chunk_refs(chunk_rec, block_group_cache,
9539 dev_extent_cache, silent);
9542 if (err == 0 && good)
9543 list_add_tail(&chunk_rec->list, good);
9544 if (err > 0 && rebuild)
9545 list_add_tail(&chunk_rec->list, rebuild);
9547 list_add_tail(&chunk_rec->list, bad);
9548 chunk_item = next_cache_extent(chunk_item);
9551 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9554 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9562 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9566 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9577 static int check_device_used(struct device_record *dev_rec,
9578 struct device_extent_tree *dext_cache)
9580 struct cache_extent *cache;
9581 struct device_extent_record *dev_extent_rec;
9584 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9586 dev_extent_rec = container_of(cache,
9587 struct device_extent_record,
9589 if (dev_extent_rec->objectid != dev_rec->devid)
9592 list_del_init(&dev_extent_rec->device_list);
9593 total_byte += dev_extent_rec->length;
9594 cache = next_cache_extent(cache);
9597 if (total_byte != dev_rec->byte_used) {
9599 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9600 total_byte, dev_rec->byte_used, dev_rec->objectid,
9601 dev_rec->type, dev_rec->offset);
9608 /* check btrfs_dev_item -> btrfs_dev_extent */
9609 static int check_devices(struct rb_root *dev_cache,
9610 struct device_extent_tree *dev_extent_cache)
9612 struct rb_node *dev_node;
9613 struct device_record *dev_rec;
9614 struct device_extent_record *dext_rec;
9618 dev_node = rb_first(dev_cache);
9620 dev_rec = container_of(dev_node, struct device_record, node);
9621 err = check_device_used(dev_rec, dev_extent_cache);
9625 dev_node = rb_next(dev_node);
9627 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9630 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9631 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9638 static int add_root_item_to_list(struct list_head *head,
9639 u64 objectid, u64 bytenr, u64 last_snapshot,
9640 u8 level, u8 drop_level,
9641 int level_size, struct btrfs_key *drop_key)
9644 struct root_item_record *ri_rec;
9645 ri_rec = malloc(sizeof(*ri_rec));
9648 ri_rec->bytenr = bytenr;
9649 ri_rec->objectid = objectid;
9650 ri_rec->level = level;
9651 ri_rec->level_size = level_size;
9652 ri_rec->drop_level = drop_level;
9653 ri_rec->last_snapshot = last_snapshot;
9655 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9656 list_add_tail(&ri_rec->list, head);
9661 static void free_root_item_list(struct list_head *list)
9663 struct root_item_record *ri_rec;
9665 while (!list_empty(list)) {
9666 ri_rec = list_first_entry(list, struct root_item_record,
9668 list_del_init(&ri_rec->list);
9673 static int deal_root_from_list(struct list_head *list,
9674 struct btrfs_root *root,
9675 struct block_info *bits,
9677 struct cache_tree *pending,
9678 struct cache_tree *seen,
9679 struct cache_tree *reada,
9680 struct cache_tree *nodes,
9681 struct cache_tree *extent_cache,
9682 struct cache_tree *chunk_cache,
9683 struct rb_root *dev_cache,
9684 struct block_group_tree *block_group_cache,
9685 struct device_extent_tree *dev_extent_cache)
9690 while (!list_empty(list)) {
9691 struct root_item_record *rec;
9692 struct extent_buffer *buf;
9693 rec = list_entry(list->next,
9694 struct root_item_record, list);
9696 buf = read_tree_block(root->fs_info->tree_root,
9697 rec->bytenr, rec->level_size, 0);
9698 if (!extent_buffer_uptodate(buf)) {
9699 free_extent_buffer(buf);
9703 ret = add_root_to_pending(buf, extent_cache, pending,
9704 seen, nodes, rec->objectid);
9708 * To rebuild extent tree, we need deal with snapshot
9709 * one by one, otherwise we deal with node firstly which
9710 * can maximize readahead.
9713 ret = run_next_block(root, bits, bits_nr, &last,
9714 pending, seen, reada, nodes,
9715 extent_cache, chunk_cache,
9716 dev_cache, block_group_cache,
9717 dev_extent_cache, rec);
9721 free_extent_buffer(buf);
9722 list_del(&rec->list);
9728 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9729 reada, nodes, extent_cache, chunk_cache,
9730 dev_cache, block_group_cache,
9731 dev_extent_cache, NULL);
9741 static int check_chunks_and_extents(struct btrfs_root *root)
9743 struct rb_root dev_cache;
9744 struct cache_tree chunk_cache;
9745 struct block_group_tree block_group_cache;
9746 struct device_extent_tree dev_extent_cache;
9747 struct cache_tree extent_cache;
9748 struct cache_tree seen;
9749 struct cache_tree pending;
9750 struct cache_tree reada;
9751 struct cache_tree nodes;
9752 struct extent_io_tree excluded_extents;
9753 struct cache_tree corrupt_blocks;
9754 struct btrfs_path path;
9755 struct btrfs_key key;
9756 struct btrfs_key found_key;
9758 struct block_info *bits;
9760 struct extent_buffer *leaf;
9762 struct btrfs_root_item ri;
9763 struct list_head dropping_trees;
9764 struct list_head normal_trees;
9765 struct btrfs_root *root1;
9770 dev_cache = RB_ROOT;
9771 cache_tree_init(&chunk_cache);
9772 block_group_tree_init(&block_group_cache);
9773 device_extent_tree_init(&dev_extent_cache);
9775 cache_tree_init(&extent_cache);
9776 cache_tree_init(&seen);
9777 cache_tree_init(&pending);
9778 cache_tree_init(&nodes);
9779 cache_tree_init(&reada);
9780 cache_tree_init(&corrupt_blocks);
9781 extent_io_tree_init(&excluded_extents);
9782 INIT_LIST_HEAD(&dropping_trees);
9783 INIT_LIST_HEAD(&normal_trees);
9786 root->fs_info->excluded_extents = &excluded_extents;
9787 root->fs_info->fsck_extent_cache = &extent_cache;
9788 root->fs_info->free_extent_hook = free_extent_hook;
9789 root->fs_info->corrupt_blocks = &corrupt_blocks;
9793 bits = malloc(bits_nr * sizeof(struct block_info));
9799 if (ctx.progress_enabled) {
9800 ctx.tp = TASK_EXTENTS;
9801 task_start(ctx.info);
9805 root1 = root->fs_info->tree_root;
9806 level = btrfs_header_level(root1->node);
9807 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9808 root1->node->start, 0, level, 0,
9809 root1->nodesize, NULL);
9812 root1 = root->fs_info->chunk_root;
9813 level = btrfs_header_level(root1->node);
9814 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9815 root1->node->start, 0, level, 0,
9816 root1->nodesize, NULL);
9819 btrfs_init_path(&path);
9822 key.type = BTRFS_ROOT_ITEM_KEY;
9823 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9828 leaf = path.nodes[0];
9829 slot = path.slots[0];
9830 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9831 ret = btrfs_next_leaf(root, &path);
9834 leaf = path.nodes[0];
9835 slot = path.slots[0];
9837 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9838 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9839 unsigned long offset;
9842 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9843 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9844 last_snapshot = btrfs_root_last_snapshot(&ri);
9845 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9846 level = btrfs_root_level(&ri);
9847 level_size = root->nodesize;
9848 ret = add_root_item_to_list(&normal_trees,
9850 btrfs_root_bytenr(&ri),
9851 last_snapshot, level,
9852 0, level_size, NULL);
9856 level = btrfs_root_level(&ri);
9857 level_size = root->nodesize;
9858 objectid = found_key.objectid;
9859 btrfs_disk_key_to_cpu(&found_key,
9861 ret = add_root_item_to_list(&dropping_trees,
9863 btrfs_root_bytenr(&ri),
9864 last_snapshot, level,
9866 level_size, &found_key);
9873 btrfs_release_path(&path);
9876 * check_block can return -EAGAIN if it fixes something, please keep
9877 * this in mind when dealing with return values from these functions, if
9878 * we get -EAGAIN we want to fall through and restart the loop.
9880 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9881 &seen, &reada, &nodes, &extent_cache,
9882 &chunk_cache, &dev_cache, &block_group_cache,
9889 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9890 &pending, &seen, &reada, &nodes,
9891 &extent_cache, &chunk_cache, &dev_cache,
9892 &block_group_cache, &dev_extent_cache);
9899 ret = check_chunks(&chunk_cache, &block_group_cache,
9900 &dev_extent_cache, NULL, NULL, NULL, 0);
9907 ret = check_extent_refs(root, &extent_cache);
9914 ret = check_devices(&dev_cache, &dev_extent_cache);
9919 task_stop(ctx.info);
9921 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9922 extent_io_tree_cleanup(&excluded_extents);
9923 root->fs_info->fsck_extent_cache = NULL;
9924 root->fs_info->free_extent_hook = NULL;
9925 root->fs_info->corrupt_blocks = NULL;
9926 root->fs_info->excluded_extents = NULL;
9929 free_chunk_cache_tree(&chunk_cache);
9930 free_device_cache_tree(&dev_cache);
9931 free_block_group_tree(&block_group_cache);
9932 free_device_extent_tree(&dev_extent_cache);
9933 free_extent_cache_tree(&seen);
9934 free_extent_cache_tree(&pending);
9935 free_extent_cache_tree(&reada);
9936 free_extent_cache_tree(&nodes);
9939 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9940 free_extent_cache_tree(&seen);
9941 free_extent_cache_tree(&pending);
9942 free_extent_cache_tree(&reada);
9943 free_extent_cache_tree(&nodes);
9944 free_chunk_cache_tree(&chunk_cache);
9945 free_block_group_tree(&block_group_cache);
9946 free_device_cache_tree(&dev_cache);
9947 free_device_extent_tree(&dev_extent_cache);
9948 free_extent_record_cache(root->fs_info, &extent_cache);
9949 free_root_item_list(&normal_trees);
9950 free_root_item_list(&dropping_trees);
9951 extent_io_tree_cleanup(&excluded_extents);
9956 * Check backrefs of a tree block given by @bytenr or @eb.
9958 * @root: the root containing the @bytenr or @eb
9959 * @eb: tree block extent buffer, can be NULL
9960 * @bytenr: bytenr of the tree block to search
9961 * @level: tree level of the tree block
9962 * @owner: owner of the tree block
9964 * Return >0 for any error found and output error message
9965 * Return 0 for no error found
9967 static int check_tree_block_ref(struct btrfs_root *root,
9968 struct extent_buffer *eb, u64 bytenr,
9969 int level, u64 owner)
9971 struct btrfs_key key;
9972 struct btrfs_root *extent_root = root->fs_info->extent_root;
9973 struct btrfs_path path;
9974 struct btrfs_extent_item *ei;
9975 struct btrfs_extent_inline_ref *iref;
9976 struct extent_buffer *leaf;
9982 u32 nodesize = root->nodesize;
9985 int tree_reloc_root = 0;
9990 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
9991 btrfs_header_bytenr(root->node) == bytenr)
9992 tree_reloc_root = 1;
9994 btrfs_init_path(&path);
9995 key.objectid = bytenr;
9996 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
9997 key.type = BTRFS_METADATA_ITEM_KEY;
9999 key.type = BTRFS_EXTENT_ITEM_KEY;
10000 key.offset = (u64)-1;
10002 /* Search for the backref in extent tree */
10003 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10005 err |= BACKREF_MISSING;
10008 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10010 err |= BACKREF_MISSING;
10014 leaf = path.nodes[0];
10015 slot = path.slots[0];
10016 btrfs_item_key_to_cpu(leaf, &key, slot);
10018 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10020 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10021 skinny_level = (int)key.offset;
10022 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10024 struct btrfs_tree_block_info *info;
10026 info = (struct btrfs_tree_block_info *)(ei + 1);
10027 skinny_level = btrfs_tree_block_level(leaf, info);
10028 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10035 if (!(btrfs_extent_flags(leaf, ei) &
10036 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10038 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10039 key.objectid, nodesize,
10040 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10041 err = BACKREF_MISMATCH;
10043 header_gen = btrfs_header_generation(eb);
10044 extent_gen = btrfs_extent_generation(leaf, ei);
10045 if (header_gen != extent_gen) {
10047 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10048 key.objectid, nodesize, header_gen,
10050 err = BACKREF_MISMATCH;
10052 if (level != skinny_level) {
10054 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10055 key.objectid, nodesize, level, skinny_level);
10056 err = BACKREF_MISMATCH;
10058 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10060 "extent[%llu %u] is referred by other roots than %llu",
10061 key.objectid, nodesize, root->objectid);
10062 err = BACKREF_MISMATCH;
10067 * Iterate the extent/metadata item to find the exact backref
10069 item_size = btrfs_item_size_nr(leaf, slot);
10070 ptr = (unsigned long)iref;
10071 end = (unsigned long)ei + item_size;
10072 while (ptr < end) {
10073 iref = (struct btrfs_extent_inline_ref *)ptr;
10074 type = btrfs_extent_inline_ref_type(leaf, iref);
10075 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10077 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10078 (offset == root->objectid || offset == owner)) {
10080 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10082 * Backref of tree reloc root points to itself, no need
10083 * to check backref any more.
10085 if (tree_reloc_root)
10088 /* Check if the backref points to valid referencer */
10089 found_ref = !check_tree_block_ref(root, NULL,
10090 offset, level + 1, owner);
10095 ptr += btrfs_extent_inline_ref_size(type);
10099 * Inlined extent item doesn't have what we need, check
10100 * TREE_BLOCK_REF_KEY
10103 btrfs_release_path(&path);
10104 key.objectid = bytenr;
10105 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10106 key.offset = root->objectid;
10108 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10113 err |= BACKREF_MISSING;
10115 btrfs_release_path(&path);
10116 if (eb && (err & BACKREF_MISSING))
10117 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10118 bytenr, nodesize, owner, level);
10123 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10125 * Return >0 any error found and output error message
10126 * Return 0 for no error found
10128 static int check_extent_data_item(struct btrfs_root *root,
10129 struct extent_buffer *eb, int slot)
10131 struct btrfs_file_extent_item *fi;
10132 struct btrfs_path path;
10133 struct btrfs_root *extent_root = root->fs_info->extent_root;
10134 struct btrfs_key fi_key;
10135 struct btrfs_key dbref_key;
10136 struct extent_buffer *leaf;
10137 struct btrfs_extent_item *ei;
10138 struct btrfs_extent_inline_ref *iref;
10139 struct btrfs_extent_data_ref *dref;
10142 u64 disk_num_bytes;
10143 u64 extent_num_bytes;
10150 int found_dbackref = 0;
10154 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10155 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10157 /* Nothing to check for hole and inline data extents */
10158 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10159 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10162 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10163 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10164 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10166 /* Check unaligned disk_num_bytes and num_bytes */
10167 if (!IS_ALIGNED(disk_num_bytes, root->sectorsize)) {
10169 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10170 fi_key.objectid, fi_key.offset, disk_num_bytes,
10172 err |= BYTES_UNALIGNED;
10174 data_bytes_allocated += disk_num_bytes;
10176 if (!IS_ALIGNED(extent_num_bytes, root->sectorsize)) {
10178 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10179 fi_key.objectid, fi_key.offset, extent_num_bytes,
10181 err |= BYTES_UNALIGNED;
10183 data_bytes_referenced += extent_num_bytes;
10185 owner = btrfs_header_owner(eb);
10187 /* Check the extent item of the file extent in extent tree */
10188 btrfs_init_path(&path);
10189 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10190 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10191 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10193 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10195 err |= BACKREF_MISSING;
10199 leaf = path.nodes[0];
10200 slot = path.slots[0];
10201 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10203 extent_flags = btrfs_extent_flags(leaf, ei);
10205 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10207 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10208 disk_bytenr, disk_num_bytes,
10209 BTRFS_EXTENT_FLAG_DATA);
10210 err |= BACKREF_MISMATCH;
10213 /* Check data backref inside that extent item */
10214 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10215 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10216 ptr = (unsigned long)iref;
10217 end = (unsigned long)ei + item_size;
10218 while (ptr < end) {
10219 iref = (struct btrfs_extent_inline_ref *)ptr;
10220 type = btrfs_extent_inline_ref_type(leaf, iref);
10221 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10223 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10224 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10225 if (ref_root == owner || ref_root == root->objectid)
10226 found_dbackref = 1;
10227 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10228 found_dbackref = !check_tree_block_ref(root, NULL,
10229 btrfs_extent_inline_ref_offset(leaf, iref),
10233 if (found_dbackref)
10235 ptr += btrfs_extent_inline_ref_size(type);
10238 /* Didn't found inlined data backref, try EXTENT_DATA_REF_KEY */
10239 if (!found_dbackref) {
10240 btrfs_release_path(&path);
10242 btrfs_init_path(&path);
10243 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10244 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10245 dbref_key.offset = hash_extent_data_ref(root->objectid,
10246 fi_key.objectid, fi_key.offset);
10248 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10249 &dbref_key, &path, 0, 0);
10251 found_dbackref = 1;
10254 if (!found_dbackref)
10255 err |= BACKREF_MISSING;
10257 btrfs_release_path(&path);
10258 if (err & BACKREF_MISSING) {
10259 error("data extent[%llu %llu] backref lost",
10260 disk_bytenr, disk_num_bytes);
10266 * Get real tree block level for the case like shared block
10267 * Return >= 0 as tree level
10268 * Return <0 for error
10270 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10272 struct extent_buffer *eb;
10273 struct btrfs_path path;
10274 struct btrfs_key key;
10275 struct btrfs_extent_item *ei;
10278 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10283 /* Search extent tree for extent generation and level */
10284 key.objectid = bytenr;
10285 key.type = BTRFS_METADATA_ITEM_KEY;
10286 key.offset = (u64)-1;
10288 btrfs_init_path(&path);
10289 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10292 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10300 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10301 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10302 struct btrfs_extent_item);
10303 flags = btrfs_extent_flags(path.nodes[0], ei);
10304 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10309 /* Get transid for later read_tree_block() check */
10310 transid = btrfs_extent_generation(path.nodes[0], ei);
10312 /* Get backref level as one source */
10313 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10314 backref_level = key.offset;
10316 struct btrfs_tree_block_info *info;
10318 info = (struct btrfs_tree_block_info *)(ei + 1);
10319 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10321 btrfs_release_path(&path);
10323 /* Get level from tree block as an alternative source */
10324 eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
10325 if (!extent_buffer_uptodate(eb)) {
10326 free_extent_buffer(eb);
10329 header_level = btrfs_header_level(eb);
10330 free_extent_buffer(eb);
10332 if (header_level != backref_level)
10334 return header_level;
10337 btrfs_release_path(&path);
10342 * Check if a tree block backref is valid (points to a valid tree block)
10343 * if level == -1, level will be resolved
10344 * Return >0 for any error found and print error message
10346 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10347 u64 bytenr, int level)
10349 struct btrfs_root *root;
10350 struct btrfs_key key;
10351 struct btrfs_path path;
10352 struct extent_buffer *eb;
10353 struct extent_buffer *node;
10354 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10358 /* Query level for level == -1 special case */
10360 level = query_tree_block_level(fs_info, bytenr);
10362 err |= REFERENCER_MISSING;
10366 key.objectid = root_id;
10367 key.type = BTRFS_ROOT_ITEM_KEY;
10368 key.offset = (u64)-1;
10370 root = btrfs_read_fs_root(fs_info, &key);
10371 if (IS_ERR(root)) {
10372 err |= REFERENCER_MISSING;
10376 /* Read out the tree block to get item/node key */
10377 eb = read_tree_block(root, bytenr, root->nodesize, 0);
10378 if (!extent_buffer_uptodate(eb)) {
10379 err |= REFERENCER_MISSING;
10380 free_extent_buffer(eb);
10384 /* Empty tree, no need to check key */
10385 if (!btrfs_header_nritems(eb) && !level) {
10386 free_extent_buffer(eb);
10391 btrfs_node_key_to_cpu(eb, &key, 0);
10393 btrfs_item_key_to_cpu(eb, &key, 0);
10395 free_extent_buffer(eb);
10397 btrfs_init_path(&path);
10398 path.lowest_level = level;
10399 /* Search with the first key, to ensure we can reach it */
10400 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10402 err |= REFERENCER_MISSING;
10406 node = path.nodes[level];
10407 if (btrfs_header_bytenr(node) != bytenr) {
10409 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10410 bytenr, nodesize, bytenr,
10411 btrfs_header_bytenr(node));
10412 err |= REFERENCER_MISMATCH;
10414 if (btrfs_header_level(node) != level) {
10416 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10417 bytenr, nodesize, level,
10418 btrfs_header_level(node));
10419 err |= REFERENCER_MISMATCH;
10423 btrfs_release_path(&path);
10425 if (err & REFERENCER_MISSING) {
10427 error("extent [%llu %d] lost referencer (owner: %llu)",
10428 bytenr, nodesize, root_id);
10431 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10432 bytenr, nodesize, root_id, level);
10439 * Check if tree block @eb is tree reloc root.
10440 * Return 0 if it's not or any problem happens
10441 * Return 1 if it's a tree reloc root
10443 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
10444 struct extent_buffer *eb)
10446 struct btrfs_root *tree_reloc_root;
10447 struct btrfs_key key;
10448 u64 bytenr = btrfs_header_bytenr(eb);
10449 u64 owner = btrfs_header_owner(eb);
10452 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
10453 key.offset = owner;
10454 key.type = BTRFS_ROOT_ITEM_KEY;
10456 tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
10457 if (IS_ERR(tree_reloc_root))
10460 if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
10462 btrfs_free_fs_root(tree_reloc_root);
10467 * Check referencer for shared block backref
10468 * If level == -1, this function will resolve the level.
10470 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10471 u64 parent, u64 bytenr, int level)
10473 struct extent_buffer *eb;
10474 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10476 int found_parent = 0;
10479 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10480 if (!extent_buffer_uptodate(eb))
10484 level = query_tree_block_level(fs_info, bytenr);
10488 /* It's possible it's a tree reloc root */
10489 if (parent == bytenr) {
10490 if (is_tree_reloc_root(fs_info, eb))
10495 if (level + 1 != btrfs_header_level(eb))
10498 nr = btrfs_header_nritems(eb);
10499 for (i = 0; i < nr; i++) {
10500 if (bytenr == btrfs_node_blockptr(eb, i)) {
10506 free_extent_buffer(eb);
10507 if (!found_parent) {
10509 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10510 bytenr, nodesize, parent, level);
10511 return REFERENCER_MISSING;
10517 * Check referencer for normal (inlined) data ref
10518 * If len == 0, it will be resolved by searching in extent tree
10520 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10521 u64 root_id, u64 objectid, u64 offset,
10522 u64 bytenr, u64 len, u32 count)
10524 struct btrfs_root *root;
10525 struct btrfs_root *extent_root = fs_info->extent_root;
10526 struct btrfs_key key;
10527 struct btrfs_path path;
10528 struct extent_buffer *leaf;
10529 struct btrfs_file_extent_item *fi;
10530 u32 found_count = 0;
10535 key.objectid = bytenr;
10536 key.type = BTRFS_EXTENT_ITEM_KEY;
10537 key.offset = (u64)-1;
10539 btrfs_init_path(&path);
10540 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10543 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10546 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10547 if (key.objectid != bytenr ||
10548 key.type != BTRFS_EXTENT_ITEM_KEY)
10551 btrfs_release_path(&path);
10553 key.objectid = root_id;
10554 key.type = BTRFS_ROOT_ITEM_KEY;
10555 key.offset = (u64)-1;
10556 btrfs_init_path(&path);
10558 root = btrfs_read_fs_root(fs_info, &key);
10562 key.objectid = objectid;
10563 key.type = BTRFS_EXTENT_DATA_KEY;
10565 * It can be nasty as data backref offset is
10566 * file offset - file extent offset, which is smaller or
10567 * equal to original backref offset. The only special case is
10568 * overflow. So we need to special check and do further search.
10570 key.offset = offset & (1ULL << 63) ? 0 : offset;
10572 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10577 * Search afterwards to get correct one
10578 * NOTE: As we must do a comprehensive check on the data backref to
10579 * make sure the dref count also matches, we must iterate all file
10580 * extents for that inode.
10583 leaf = path.nodes[0];
10584 slot = path.slots[0];
10586 btrfs_item_key_to_cpu(leaf, &key, slot);
10587 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10589 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10591 * Except normal disk bytenr and disk num bytes, we still
10592 * need to do extra check on dbackref offset as
10593 * dbackref offset = file_offset - file_extent_offset
10595 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10596 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10597 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10601 ret = btrfs_next_item(root, &path);
10606 btrfs_release_path(&path);
10607 if (found_count != count) {
10609 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10610 bytenr, len, root_id, objectid, offset, count, found_count);
10611 return REFERENCER_MISSING;
10617 * Check if the referencer of a shared data backref exists
10619 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10620 u64 parent, u64 bytenr)
10622 struct extent_buffer *eb;
10623 struct btrfs_key key;
10624 struct btrfs_file_extent_item *fi;
10625 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10627 int found_parent = 0;
10630 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10631 if (!extent_buffer_uptodate(eb))
10634 nr = btrfs_header_nritems(eb);
10635 for (i = 0; i < nr; i++) {
10636 btrfs_item_key_to_cpu(eb, &key, i);
10637 if (key.type != BTRFS_EXTENT_DATA_KEY)
10640 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10641 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10644 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10651 free_extent_buffer(eb);
10652 if (!found_parent) {
10653 error("shared extent %llu referencer lost (parent: %llu)",
10655 return REFERENCER_MISSING;
10661 * This function will check a given extent item, including its backref and
10662 * itself (like crossing stripe boundary and type)
10664 * Since we don't use extent_record anymore, introduce new error bit
10666 static int check_extent_item(struct btrfs_fs_info *fs_info,
10667 struct extent_buffer *eb, int slot)
10669 struct btrfs_extent_item *ei;
10670 struct btrfs_extent_inline_ref *iref;
10671 struct btrfs_extent_data_ref *dref;
10675 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10676 u32 item_size = btrfs_item_size_nr(eb, slot);
10681 struct btrfs_key key;
10685 btrfs_item_key_to_cpu(eb, &key, slot);
10686 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10687 bytes_used += key.offset;
10689 bytes_used += nodesize;
10691 if (item_size < sizeof(*ei)) {
10693 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10694 * old thing when on disk format is still un-determined.
10695 * No need to care about it anymore
10697 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10701 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10702 flags = btrfs_extent_flags(eb, ei);
10704 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10706 if (metadata && check_crossing_stripes(global_info, key.objectid,
10708 error("bad metadata [%llu, %llu) crossing stripe boundary",
10709 key.objectid, key.objectid + nodesize);
10710 err |= CROSSING_STRIPE_BOUNDARY;
10713 ptr = (unsigned long)(ei + 1);
10715 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10716 /* Old EXTENT_ITEM metadata */
10717 struct btrfs_tree_block_info *info;
10719 info = (struct btrfs_tree_block_info *)ptr;
10720 level = btrfs_tree_block_level(eb, info);
10721 ptr += sizeof(struct btrfs_tree_block_info);
10723 /* New METADATA_ITEM */
10724 level = key.offset;
10726 end = (unsigned long)ei + item_size;
10729 err |= ITEM_SIZE_MISMATCH;
10733 /* Now check every backref in this extent item */
10735 iref = (struct btrfs_extent_inline_ref *)ptr;
10736 type = btrfs_extent_inline_ref_type(eb, iref);
10737 offset = btrfs_extent_inline_ref_offset(eb, iref);
10739 case BTRFS_TREE_BLOCK_REF_KEY:
10740 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10744 case BTRFS_SHARED_BLOCK_REF_KEY:
10745 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10749 case BTRFS_EXTENT_DATA_REF_KEY:
10750 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10751 ret = check_extent_data_backref(fs_info,
10752 btrfs_extent_data_ref_root(eb, dref),
10753 btrfs_extent_data_ref_objectid(eb, dref),
10754 btrfs_extent_data_ref_offset(eb, dref),
10755 key.objectid, key.offset,
10756 btrfs_extent_data_ref_count(eb, dref));
10759 case BTRFS_SHARED_DATA_REF_KEY:
10760 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10764 error("extent[%llu %d %llu] has unknown ref type: %d",
10765 key.objectid, key.type, key.offset, type);
10766 err |= UNKNOWN_TYPE;
10770 ptr += btrfs_extent_inline_ref_size(type);
10779 * Check if a dev extent item is referred correctly by its chunk
10781 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10782 struct extent_buffer *eb, int slot)
10784 struct btrfs_root *chunk_root = fs_info->chunk_root;
10785 struct btrfs_dev_extent *ptr;
10786 struct btrfs_path path;
10787 struct btrfs_key chunk_key;
10788 struct btrfs_key devext_key;
10789 struct btrfs_chunk *chunk;
10790 struct extent_buffer *l;
10794 int found_chunk = 0;
10797 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10798 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10799 length = btrfs_dev_extent_length(eb, ptr);
10801 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10802 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10803 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10805 btrfs_init_path(&path);
10806 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10811 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10812 if (btrfs_chunk_length(l, chunk) != length)
10815 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10816 for (i = 0; i < num_stripes; i++) {
10817 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10818 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10820 if (devid == devext_key.objectid &&
10821 offset == devext_key.offset) {
10827 btrfs_release_path(&path);
10828 if (!found_chunk) {
10830 "device extent[%llu, %llu, %llu] did not find the related chunk",
10831 devext_key.objectid, devext_key.offset, length);
10832 return REFERENCER_MISSING;
10838 * Check if the used space is correct with the dev item
10840 static int check_dev_item(struct btrfs_fs_info *fs_info,
10841 struct extent_buffer *eb, int slot)
10843 struct btrfs_root *dev_root = fs_info->dev_root;
10844 struct btrfs_dev_item *dev_item;
10845 struct btrfs_path path;
10846 struct btrfs_key key;
10847 struct btrfs_dev_extent *ptr;
10853 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10854 dev_id = btrfs_device_id(eb, dev_item);
10855 used = btrfs_device_bytes_used(eb, dev_item);
10857 key.objectid = dev_id;
10858 key.type = BTRFS_DEV_EXTENT_KEY;
10861 btrfs_init_path(&path);
10862 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
10864 btrfs_item_key_to_cpu(eb, &key, slot);
10865 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
10866 key.objectid, key.type, key.offset);
10867 btrfs_release_path(&path);
10868 return REFERENCER_MISSING;
10871 /* Iterate dev_extents to calculate the used space of a device */
10873 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10875 if (key.objectid > dev_id)
10877 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
10880 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
10881 struct btrfs_dev_extent);
10882 total += btrfs_dev_extent_length(path.nodes[0], ptr);
10884 ret = btrfs_next_item(dev_root, &path);
10888 btrfs_release_path(&path);
10890 if (used != total) {
10891 btrfs_item_key_to_cpu(eb, &key, slot);
10893 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
10894 total, used, BTRFS_ROOT_TREE_OBJECTID,
10895 BTRFS_DEV_EXTENT_KEY, dev_id);
10896 return ACCOUNTING_MISMATCH;
10902 * Check a block group item with its referener (chunk) and its used space
10903 * with extent/metadata item
10905 static int check_block_group_item(struct btrfs_fs_info *fs_info,
10906 struct extent_buffer *eb, int slot)
10908 struct btrfs_root *extent_root = fs_info->extent_root;
10909 struct btrfs_root *chunk_root = fs_info->chunk_root;
10910 struct btrfs_block_group_item *bi;
10911 struct btrfs_block_group_item bg_item;
10912 struct btrfs_path path;
10913 struct btrfs_key bg_key;
10914 struct btrfs_key chunk_key;
10915 struct btrfs_key extent_key;
10916 struct btrfs_chunk *chunk;
10917 struct extent_buffer *leaf;
10918 struct btrfs_extent_item *ei;
10919 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10927 btrfs_item_key_to_cpu(eb, &bg_key, slot);
10928 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
10929 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
10930 used = btrfs_block_group_used(&bg_item);
10931 bg_flags = btrfs_block_group_flags(&bg_item);
10933 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
10934 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10935 chunk_key.offset = bg_key.objectid;
10937 btrfs_init_path(&path);
10938 /* Search for the referencer chunk */
10939 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10942 "block group[%llu %llu] did not find the related chunk item",
10943 bg_key.objectid, bg_key.offset);
10944 err |= REFERENCER_MISSING;
10946 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
10947 struct btrfs_chunk);
10948 if (btrfs_chunk_length(path.nodes[0], chunk) !=
10951 "block group[%llu %llu] related chunk item length does not match",
10952 bg_key.objectid, bg_key.offset);
10953 err |= REFERENCER_MISMATCH;
10956 btrfs_release_path(&path);
10958 /* Search from the block group bytenr */
10959 extent_key.objectid = bg_key.objectid;
10960 extent_key.type = 0;
10961 extent_key.offset = 0;
10963 btrfs_init_path(&path);
10964 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
10968 /* Iterate extent tree to account used space */
10970 leaf = path.nodes[0];
10971 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
10972 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
10975 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
10976 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
10978 if (extent_key.objectid < bg_key.objectid)
10981 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
10984 total += extent_key.offset;
10986 ei = btrfs_item_ptr(leaf, path.slots[0],
10987 struct btrfs_extent_item);
10988 flags = btrfs_extent_flags(leaf, ei);
10989 if (flags & BTRFS_EXTENT_FLAG_DATA) {
10990 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
10992 "bad extent[%llu, %llu) type mismatch with chunk",
10993 extent_key.objectid,
10994 extent_key.objectid + extent_key.offset);
10995 err |= CHUNK_TYPE_MISMATCH;
10997 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
10998 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
10999 BTRFS_BLOCK_GROUP_METADATA))) {
11001 "bad extent[%llu, %llu) type mismatch with chunk",
11002 extent_key.objectid,
11003 extent_key.objectid + nodesize);
11004 err |= CHUNK_TYPE_MISMATCH;
11008 ret = btrfs_next_item(extent_root, &path);
11014 btrfs_release_path(&path);
11016 if (total != used) {
11018 "block group[%llu %llu] used %llu but extent items used %llu",
11019 bg_key.objectid, bg_key.offset, used, total);
11020 err |= ACCOUNTING_MISMATCH;
11026 * Check a chunk item.
11027 * Including checking all referred dev_extents and block group
11029 static int check_chunk_item(struct btrfs_fs_info *fs_info,
11030 struct extent_buffer *eb, int slot)
11032 struct btrfs_root *extent_root = fs_info->extent_root;
11033 struct btrfs_root *dev_root = fs_info->dev_root;
11034 struct btrfs_path path;
11035 struct btrfs_key chunk_key;
11036 struct btrfs_key bg_key;
11037 struct btrfs_key devext_key;
11038 struct btrfs_chunk *chunk;
11039 struct extent_buffer *leaf;
11040 struct btrfs_block_group_item *bi;
11041 struct btrfs_block_group_item bg_item;
11042 struct btrfs_dev_extent *ptr;
11043 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
11055 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11056 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11057 length = btrfs_chunk_length(eb, chunk);
11058 chunk_end = chunk_key.offset + length;
11059 if (!IS_ALIGNED(length, sectorsize)) {
11060 error("chunk[%llu %llu) not aligned to %u",
11061 chunk_key.offset, chunk_end, sectorsize);
11062 err |= BYTES_UNALIGNED;
11066 type = btrfs_chunk_type(eb, chunk);
11067 profile = type & BTRFS_BLOCK_GROUP_PROFILE_MASK;
11068 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
11069 error("chunk[%llu %llu) has no chunk type",
11070 chunk_key.offset, chunk_end);
11071 err |= UNKNOWN_TYPE;
11073 if (profile && (profile & (profile - 1))) {
11074 error("chunk[%llu %llu) multiple profiles detected: %llx",
11075 chunk_key.offset, chunk_end, profile);
11076 err |= UNKNOWN_TYPE;
11079 bg_key.objectid = chunk_key.offset;
11080 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11081 bg_key.offset = length;
11083 btrfs_init_path(&path);
11084 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11087 "chunk[%llu %llu) did not find the related block group item",
11088 chunk_key.offset, chunk_end);
11089 err |= REFERENCER_MISSING;
11091 leaf = path.nodes[0];
11092 bi = btrfs_item_ptr(leaf, path.slots[0],
11093 struct btrfs_block_group_item);
11094 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11096 if (btrfs_block_group_flags(&bg_item) != type) {
11098 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11099 chunk_key.offset, chunk_end, type,
11100 btrfs_block_group_flags(&bg_item));
11101 err |= REFERENCER_MISSING;
11105 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11106 for (i = 0; i < num_stripes; i++) {
11107 btrfs_release_path(&path);
11108 btrfs_init_path(&path);
11109 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11110 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11111 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11113 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11116 goto not_match_dev;
11118 leaf = path.nodes[0];
11119 ptr = btrfs_item_ptr(leaf, path.slots[0],
11120 struct btrfs_dev_extent);
11121 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11122 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11123 if (objectid != chunk_key.objectid ||
11124 offset != chunk_key.offset ||
11125 btrfs_dev_extent_length(leaf, ptr) != length)
11126 goto not_match_dev;
11129 err |= BACKREF_MISSING;
11131 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11132 chunk_key.objectid, chunk_end, i);
11135 btrfs_release_path(&path);
11141 * Main entry function to check known items and update related accounting info
11143 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11145 struct btrfs_fs_info *fs_info = root->fs_info;
11146 struct btrfs_key key;
11149 struct btrfs_extent_data_ref *dref;
11154 btrfs_item_key_to_cpu(eb, &key, slot);
11158 case BTRFS_EXTENT_DATA_KEY:
11159 ret = check_extent_data_item(root, eb, slot);
11162 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11163 ret = check_block_group_item(fs_info, eb, slot);
11166 case BTRFS_DEV_ITEM_KEY:
11167 ret = check_dev_item(fs_info, eb, slot);
11170 case BTRFS_CHUNK_ITEM_KEY:
11171 ret = check_chunk_item(fs_info, eb, slot);
11174 case BTRFS_DEV_EXTENT_KEY:
11175 ret = check_dev_extent_item(fs_info, eb, slot);
11178 case BTRFS_EXTENT_ITEM_KEY:
11179 case BTRFS_METADATA_ITEM_KEY:
11180 ret = check_extent_item(fs_info, eb, slot);
11183 case BTRFS_EXTENT_CSUM_KEY:
11184 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11186 case BTRFS_TREE_BLOCK_REF_KEY:
11187 ret = check_tree_block_backref(fs_info, key.offset,
11191 case BTRFS_EXTENT_DATA_REF_KEY:
11192 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11193 ret = check_extent_data_backref(fs_info,
11194 btrfs_extent_data_ref_root(eb, dref),
11195 btrfs_extent_data_ref_objectid(eb, dref),
11196 btrfs_extent_data_ref_offset(eb, dref),
11198 btrfs_extent_data_ref_count(eb, dref));
11201 case BTRFS_SHARED_BLOCK_REF_KEY:
11202 ret = check_shared_block_backref(fs_info, key.offset,
11206 case BTRFS_SHARED_DATA_REF_KEY:
11207 ret = check_shared_data_backref(fs_info, key.offset,
11215 if (++slot < btrfs_header_nritems(eb))
11222 * Helper function for later fs/subvol tree check. To determine if a tree
11223 * block should be checked.
11224 * This function will ensure only the direct referencer with lowest rootid to
11225 * check a fs/subvolume tree block.
11227 * Backref check at extent tree would detect errors like missing subvolume
11228 * tree, so we can do aggressive check to reduce duplicated checks.
11230 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11232 struct btrfs_root *extent_root = root->fs_info->extent_root;
11233 struct btrfs_key key;
11234 struct btrfs_path path;
11235 struct extent_buffer *leaf;
11237 struct btrfs_extent_item *ei;
11243 struct btrfs_extent_inline_ref *iref;
11246 btrfs_init_path(&path);
11247 key.objectid = btrfs_header_bytenr(eb);
11248 key.type = BTRFS_METADATA_ITEM_KEY;
11249 key.offset = (u64)-1;
11252 * Any failure in backref resolving means we can't determine
11253 * whom the tree block belongs to.
11254 * So in that case, we need to check that tree block
11256 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11260 ret = btrfs_previous_extent_item(extent_root, &path,
11261 btrfs_header_bytenr(eb));
11265 leaf = path.nodes[0];
11266 slot = path.slots[0];
11267 btrfs_item_key_to_cpu(leaf, &key, slot);
11268 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11270 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11271 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11273 struct btrfs_tree_block_info *info;
11275 info = (struct btrfs_tree_block_info *)(ei + 1);
11276 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11279 item_size = btrfs_item_size_nr(leaf, slot);
11280 ptr = (unsigned long)iref;
11281 end = (unsigned long)ei + item_size;
11282 while (ptr < end) {
11283 iref = (struct btrfs_extent_inline_ref *)ptr;
11284 type = btrfs_extent_inline_ref_type(leaf, iref);
11285 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11288 * We only check the tree block if current root is
11289 * the lowest referencer of it.
11291 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11292 offset < root->objectid) {
11293 btrfs_release_path(&path);
11297 ptr += btrfs_extent_inline_ref_size(type);
11300 * Normally we should also check keyed tree block ref, but that may be
11301 * very time consuming. Inlined ref should already make us skip a lot
11302 * of refs now. So skip search keyed tree block ref.
11306 btrfs_release_path(&path);
11311 * Traversal function for tree block. We will do:
11312 * 1) Skip shared fs/subvolume tree blocks
11313 * 2) Update related bytes accounting
11314 * 3) Pre-order traversal
11316 static int traverse_tree_block(struct btrfs_root *root,
11317 struct extent_buffer *node)
11319 struct extent_buffer *eb;
11320 struct btrfs_key key;
11321 struct btrfs_key drop_key;
11329 * Skip shared fs/subvolume tree block, in that case they will
11330 * be checked by referencer with lowest rootid
11332 if (is_fstree(root->objectid) && !should_check(root, node))
11335 /* Update bytes accounting */
11336 total_btree_bytes += node->len;
11337 if (fs_root_objectid(btrfs_header_owner(node)))
11338 total_fs_tree_bytes += node->len;
11339 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11340 total_extent_tree_bytes += node->len;
11341 if (!found_old_backref &&
11342 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11343 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11344 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11345 found_old_backref = 1;
11347 /* pre-order tranversal, check itself first */
11348 level = btrfs_header_level(node);
11349 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11350 btrfs_header_level(node),
11351 btrfs_header_owner(node));
11355 "check %s failed root %llu bytenr %llu level %d, force continue check",
11356 level ? "node":"leaf", root->objectid,
11357 btrfs_header_bytenr(node), btrfs_header_level(node));
11360 btree_space_waste += btrfs_leaf_free_space(root, node);
11361 ret = check_leaf_items(root, node);
11366 nr = btrfs_header_nritems(node);
11367 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11368 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11369 sizeof(struct btrfs_key_ptr);
11371 /* Then check all its children */
11372 for (i = 0; i < nr; i++) {
11373 u64 blocknr = btrfs_node_blockptr(node, i);
11375 btrfs_node_key_to_cpu(node, &key, i);
11376 if (level == root->root_item.drop_level &&
11377 is_dropped_key(&key, &drop_key))
11381 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11382 * to call the function itself.
11384 eb = read_tree_block(root, blocknr, root->nodesize, 0);
11385 if (extent_buffer_uptodate(eb)) {
11386 ret = traverse_tree_block(root, eb);
11389 free_extent_buffer(eb);
11396 * Low memory usage version check_chunks_and_extents.
11398 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11400 struct btrfs_path path;
11401 struct btrfs_key key;
11402 struct btrfs_root *root1;
11403 struct btrfs_root *cur_root;
11407 root1 = root->fs_info->chunk_root;
11408 ret = traverse_tree_block(root1, root1->node);
11411 root1 = root->fs_info->tree_root;
11412 ret = traverse_tree_block(root1, root1->node);
11415 btrfs_init_path(&path);
11416 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11418 key.type = BTRFS_ROOT_ITEM_KEY;
11420 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11422 error("cannot find extent treet in tree_root");
11427 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11428 if (key.type != BTRFS_ROOT_ITEM_KEY)
11430 key.offset = (u64)-1;
11432 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11433 cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
11436 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11437 if (IS_ERR(cur_root) || !cur_root) {
11438 error("failed to read tree: %lld", key.objectid);
11442 ret = traverse_tree_block(cur_root, cur_root->node);
11445 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11446 btrfs_free_fs_root(cur_root);
11448 ret = btrfs_next_item(root1, &path);
11454 btrfs_release_path(&path);
11458 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11459 struct btrfs_root *root, int overwrite)
11461 struct extent_buffer *c;
11462 struct extent_buffer *old = root->node;
11465 struct btrfs_disk_key disk_key = {0,0,0};
11471 extent_buffer_get(c);
11474 c = btrfs_alloc_free_block(trans, root,
11476 root->root_key.objectid,
11477 &disk_key, level, 0, 0);
11480 extent_buffer_get(c);
11484 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11485 btrfs_set_header_level(c, level);
11486 btrfs_set_header_bytenr(c, c->start);
11487 btrfs_set_header_generation(c, trans->transid);
11488 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11489 btrfs_set_header_owner(c, root->root_key.objectid);
11491 write_extent_buffer(c, root->fs_info->fsid,
11492 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11494 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11495 btrfs_header_chunk_tree_uuid(c),
11498 btrfs_mark_buffer_dirty(c);
11500 * this case can happen in the following case:
11502 * 1.overwrite previous root.
11504 * 2.reinit reloc data root, this is because we skip pin
11505 * down reloc data tree before which means we can allocate
11506 * same block bytenr here.
11508 if (old->start == c->start) {
11509 btrfs_set_root_generation(&root->root_item,
11511 root->root_item.level = btrfs_header_level(root->node);
11512 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11513 &root->root_key, &root->root_item);
11515 free_extent_buffer(c);
11519 free_extent_buffer(old);
11521 add_root_to_dirty_list(root);
11525 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11526 struct extent_buffer *eb, int tree_root)
11528 struct extent_buffer *tmp;
11529 struct btrfs_root_item *ri;
11530 struct btrfs_key key;
11533 int level = btrfs_header_level(eb);
11539 * If we have pinned this block before, don't pin it again.
11540 * This can not only avoid forever loop with broken filesystem
11541 * but also give us some speedups.
11543 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11544 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11547 btrfs_pin_extent(fs_info, eb->start, eb->len);
11549 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11550 nritems = btrfs_header_nritems(eb);
11551 for (i = 0; i < nritems; i++) {
11553 btrfs_item_key_to_cpu(eb, &key, i);
11554 if (key.type != BTRFS_ROOT_ITEM_KEY)
11556 /* Skip the extent root and reloc roots */
11557 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11558 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11559 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11561 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11562 bytenr = btrfs_disk_root_bytenr(eb, ri);
11565 * If at any point we start needing the real root we
11566 * will have to build a stump root for the root we are
11567 * in, but for now this doesn't actually use the root so
11568 * just pass in extent_root.
11570 tmp = read_tree_block(fs_info->extent_root, bytenr,
11572 if (!extent_buffer_uptodate(tmp)) {
11573 fprintf(stderr, "Error reading root block\n");
11576 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11577 free_extent_buffer(tmp);
11581 bytenr = btrfs_node_blockptr(eb, i);
11583 /* If we aren't the tree root don't read the block */
11584 if (level == 1 && !tree_root) {
11585 btrfs_pin_extent(fs_info, bytenr, nodesize);
11589 tmp = read_tree_block(fs_info->extent_root, bytenr,
11591 if (!extent_buffer_uptodate(tmp)) {
11592 fprintf(stderr, "Error reading tree block\n");
11595 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11596 free_extent_buffer(tmp);
11605 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11609 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11613 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11616 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11618 struct btrfs_block_group_cache *cache;
11619 struct btrfs_path path;
11620 struct extent_buffer *leaf;
11621 struct btrfs_chunk *chunk;
11622 struct btrfs_key key;
11626 btrfs_init_path(&path);
11628 key.type = BTRFS_CHUNK_ITEM_KEY;
11630 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11632 btrfs_release_path(&path);
11637 * We do this in case the block groups were screwed up and had alloc
11638 * bits that aren't actually set on the chunks. This happens with
11639 * restored images every time and could happen in real life I guess.
11641 fs_info->avail_data_alloc_bits = 0;
11642 fs_info->avail_metadata_alloc_bits = 0;
11643 fs_info->avail_system_alloc_bits = 0;
11645 /* First we need to create the in-memory block groups */
11647 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11648 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11650 btrfs_release_path(&path);
11658 leaf = path.nodes[0];
11659 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11660 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11665 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11666 btrfs_add_block_group(fs_info, 0,
11667 btrfs_chunk_type(leaf, chunk),
11668 key.objectid, key.offset,
11669 btrfs_chunk_length(leaf, chunk));
11670 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11671 key.offset + btrfs_chunk_length(leaf, chunk));
11676 cache = btrfs_lookup_first_block_group(fs_info, start);
11680 start = cache->key.objectid + cache->key.offset;
11683 btrfs_release_path(&path);
11687 static int reset_balance(struct btrfs_trans_handle *trans,
11688 struct btrfs_fs_info *fs_info)
11690 struct btrfs_root *root = fs_info->tree_root;
11691 struct btrfs_path path;
11692 struct extent_buffer *leaf;
11693 struct btrfs_key key;
11694 int del_slot, del_nr = 0;
11698 btrfs_init_path(&path);
11699 key.objectid = BTRFS_BALANCE_OBJECTID;
11700 key.type = BTRFS_BALANCE_ITEM_KEY;
11702 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11707 goto reinit_data_reloc;
11712 ret = btrfs_del_item(trans, root, &path);
11715 btrfs_release_path(&path);
11717 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11718 key.type = BTRFS_ROOT_ITEM_KEY;
11720 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11724 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11729 ret = btrfs_del_items(trans, root, &path,
11736 btrfs_release_path(&path);
11739 ret = btrfs_search_slot(trans, root, &key, &path,
11746 leaf = path.nodes[0];
11747 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11748 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11750 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11755 del_slot = path.slots[0];
11764 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11768 btrfs_release_path(&path);
11771 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11772 key.type = BTRFS_ROOT_ITEM_KEY;
11773 key.offset = (u64)-1;
11774 root = btrfs_read_fs_root(fs_info, &key);
11775 if (IS_ERR(root)) {
11776 fprintf(stderr, "Error reading data reloc tree\n");
11777 ret = PTR_ERR(root);
11780 record_root_in_trans(trans, root);
11781 ret = btrfs_fsck_reinit_root(trans, root, 0);
11784 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11786 btrfs_release_path(&path);
11790 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11791 struct btrfs_fs_info *fs_info)
11797 * The only reason we don't do this is because right now we're just
11798 * walking the trees we find and pinning down their bytes, we don't look
11799 * at any of the leaves. In order to do mixed groups we'd have to check
11800 * the leaves of any fs roots and pin down the bytes for any file
11801 * extents we find. Not hard but why do it if we don't have to?
11803 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11804 fprintf(stderr, "We don't support re-initing the extent tree "
11805 "for mixed block groups yet, please notify a btrfs "
11806 "developer you want to do this so they can add this "
11807 "functionality.\n");
11812 * first we need to walk all of the trees except the extent tree and pin
11813 * down the bytes that are in use so we don't overwrite any existing
11816 ret = pin_metadata_blocks(fs_info);
11818 fprintf(stderr, "error pinning down used bytes\n");
11823 * Need to drop all the block groups since we're going to recreate all
11826 btrfs_free_block_groups(fs_info);
11827 ret = reset_block_groups(fs_info);
11829 fprintf(stderr, "error resetting the block groups\n");
11833 /* Ok we can allocate now, reinit the extent root */
11834 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11836 fprintf(stderr, "extent root initialization failed\n");
11838 * When the transaction code is updated we should end the
11839 * transaction, but for now progs only knows about commit so
11840 * just return an error.
11846 * Now we have all the in-memory block groups setup so we can make
11847 * allocations properly, and the metadata we care about is safe since we
11848 * pinned all of it above.
11851 struct btrfs_block_group_cache *cache;
11853 cache = btrfs_lookup_first_block_group(fs_info, start);
11856 start = cache->key.objectid + cache->key.offset;
11857 ret = btrfs_insert_item(trans, fs_info->extent_root,
11858 &cache->key, &cache->item,
11859 sizeof(cache->item));
11861 fprintf(stderr, "Error adding block group\n");
11864 btrfs_extent_post_op(trans, fs_info->extent_root);
11867 ret = reset_balance(trans, fs_info);
11869 fprintf(stderr, "error resetting the pending balance\n");
11874 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
11876 struct btrfs_path path;
11877 struct btrfs_trans_handle *trans;
11878 struct btrfs_key key;
11881 printf("Recowing metadata block %llu\n", eb->start);
11882 key.objectid = btrfs_header_owner(eb);
11883 key.type = BTRFS_ROOT_ITEM_KEY;
11884 key.offset = (u64)-1;
11886 root = btrfs_read_fs_root(root->fs_info, &key);
11887 if (IS_ERR(root)) {
11888 fprintf(stderr, "Couldn't find owner root %llu\n",
11890 return PTR_ERR(root);
11893 trans = btrfs_start_transaction(root, 1);
11895 return PTR_ERR(trans);
11897 btrfs_init_path(&path);
11898 path.lowest_level = btrfs_header_level(eb);
11899 if (path.lowest_level)
11900 btrfs_node_key_to_cpu(eb, &key, 0);
11902 btrfs_item_key_to_cpu(eb, &key, 0);
11904 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
11905 btrfs_commit_transaction(trans, root);
11906 btrfs_release_path(&path);
11910 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
11912 struct btrfs_path path;
11913 struct btrfs_trans_handle *trans;
11914 struct btrfs_key key;
11917 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
11918 bad->key.type, bad->key.offset);
11919 key.objectid = bad->root_id;
11920 key.type = BTRFS_ROOT_ITEM_KEY;
11921 key.offset = (u64)-1;
11923 root = btrfs_read_fs_root(root->fs_info, &key);
11924 if (IS_ERR(root)) {
11925 fprintf(stderr, "Couldn't find owner root %llu\n",
11927 return PTR_ERR(root);
11930 trans = btrfs_start_transaction(root, 1);
11932 return PTR_ERR(trans);
11934 btrfs_init_path(&path);
11935 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
11941 ret = btrfs_del_item(trans, root, &path);
11943 btrfs_commit_transaction(trans, root);
11944 btrfs_release_path(&path);
11948 static int zero_log_tree(struct btrfs_root *root)
11950 struct btrfs_trans_handle *trans;
11953 trans = btrfs_start_transaction(root, 1);
11954 if (IS_ERR(trans)) {
11955 ret = PTR_ERR(trans);
11958 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
11959 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
11960 ret = btrfs_commit_transaction(trans, root);
11964 static int populate_csum(struct btrfs_trans_handle *trans,
11965 struct btrfs_root *csum_root, char *buf, u64 start,
11972 while (offset < len) {
11973 sectorsize = csum_root->sectorsize;
11974 ret = read_extent_data(csum_root, buf, start + offset,
11978 ret = btrfs_csum_file_block(trans, csum_root, start + len,
11979 start + offset, buf, sectorsize);
11982 offset += sectorsize;
11987 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
11988 struct btrfs_root *csum_root,
11989 struct btrfs_root *cur_root)
11991 struct btrfs_path path;
11992 struct btrfs_key key;
11993 struct extent_buffer *node;
11994 struct btrfs_file_extent_item *fi;
12001 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
12005 btrfs_init_path(&path);
12009 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
12012 /* Iterate all regular file extents and fill its csum */
12014 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12016 if (key.type != BTRFS_EXTENT_DATA_KEY)
12018 node = path.nodes[0];
12019 slot = path.slots[0];
12020 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
12021 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
12023 start = btrfs_file_extent_disk_bytenr(node, fi);
12024 len = btrfs_file_extent_disk_num_bytes(node, fi);
12026 ret = populate_csum(trans, csum_root, buf, start, len);
12027 if (ret == -EEXIST)
12033 * TODO: if next leaf is corrupted, jump to nearest next valid
12036 ret = btrfs_next_item(cur_root, &path);
12046 btrfs_release_path(&path);
12051 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12052 struct btrfs_root *csum_root)
12054 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12055 struct btrfs_path path;
12056 struct btrfs_root *tree_root = fs_info->tree_root;
12057 struct btrfs_root *cur_root;
12058 struct extent_buffer *node;
12059 struct btrfs_key key;
12063 btrfs_init_path(&path);
12064 key.objectid = BTRFS_FS_TREE_OBJECTID;
12066 key.type = BTRFS_ROOT_ITEM_KEY;
12067 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12076 node = path.nodes[0];
12077 slot = path.slots[0];
12078 btrfs_item_key_to_cpu(node, &key, slot);
12079 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12081 if (key.type != BTRFS_ROOT_ITEM_KEY)
12083 if (!is_fstree(key.objectid))
12085 key.offset = (u64)-1;
12087 cur_root = btrfs_read_fs_root(fs_info, &key);
12088 if (IS_ERR(cur_root) || !cur_root) {
12089 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12093 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12098 ret = btrfs_next_item(tree_root, &path);
12108 btrfs_release_path(&path);
12112 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12113 struct btrfs_root *csum_root)
12115 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12116 struct btrfs_path path;
12117 struct btrfs_extent_item *ei;
12118 struct extent_buffer *leaf;
12120 struct btrfs_key key;
12123 btrfs_init_path(&path);
12125 key.type = BTRFS_EXTENT_ITEM_KEY;
12127 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12129 btrfs_release_path(&path);
12133 buf = malloc(csum_root->sectorsize);
12135 btrfs_release_path(&path);
12140 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12141 ret = btrfs_next_leaf(extent_root, &path);
12149 leaf = path.nodes[0];
12151 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12152 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12157 ei = btrfs_item_ptr(leaf, path.slots[0],
12158 struct btrfs_extent_item);
12159 if (!(btrfs_extent_flags(leaf, ei) &
12160 BTRFS_EXTENT_FLAG_DATA)) {
12165 ret = populate_csum(trans, csum_root, buf, key.objectid,
12172 btrfs_release_path(&path);
12178 * Recalculate the csum and put it into the csum tree.
12180 * Extent tree init will wipe out all the extent info, so in that case, we
12181 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12182 * will use fs/subvol trees to init the csum tree.
12184 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12185 struct btrfs_root *csum_root,
12186 int search_fs_tree)
12188 if (search_fs_tree)
12189 return fill_csum_tree_from_fs(trans, csum_root);
12191 return fill_csum_tree_from_extent(trans, csum_root);
12194 static void free_roots_info_cache(void)
12196 if (!roots_info_cache)
12199 while (!cache_tree_empty(roots_info_cache)) {
12200 struct cache_extent *entry;
12201 struct root_item_info *rii;
12203 entry = first_cache_extent(roots_info_cache);
12206 remove_cache_extent(roots_info_cache, entry);
12207 rii = container_of(entry, struct root_item_info, cache_extent);
12211 free(roots_info_cache);
12212 roots_info_cache = NULL;
12215 static int build_roots_info_cache(struct btrfs_fs_info *info)
12218 struct btrfs_key key;
12219 struct extent_buffer *leaf;
12220 struct btrfs_path path;
12222 if (!roots_info_cache) {
12223 roots_info_cache = malloc(sizeof(*roots_info_cache));
12224 if (!roots_info_cache)
12226 cache_tree_init(roots_info_cache);
12229 btrfs_init_path(&path);
12231 key.type = BTRFS_EXTENT_ITEM_KEY;
12233 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12236 leaf = path.nodes[0];
12239 struct btrfs_key found_key;
12240 struct btrfs_extent_item *ei;
12241 struct btrfs_extent_inline_ref *iref;
12242 int slot = path.slots[0];
12247 struct cache_extent *entry;
12248 struct root_item_info *rii;
12250 if (slot >= btrfs_header_nritems(leaf)) {
12251 ret = btrfs_next_leaf(info->extent_root, &path);
12258 leaf = path.nodes[0];
12259 slot = path.slots[0];
12262 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12264 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12265 found_key.type != BTRFS_METADATA_ITEM_KEY)
12268 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12269 flags = btrfs_extent_flags(leaf, ei);
12271 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12272 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12275 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12276 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12277 level = found_key.offset;
12279 struct btrfs_tree_block_info *binfo;
12281 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12282 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12283 level = btrfs_tree_block_level(leaf, binfo);
12287 * For a root extent, it must be of the following type and the
12288 * first (and only one) iref in the item.
12290 type = btrfs_extent_inline_ref_type(leaf, iref);
12291 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12294 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12295 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12297 rii = malloc(sizeof(struct root_item_info));
12302 rii->cache_extent.start = root_id;
12303 rii->cache_extent.size = 1;
12304 rii->level = (u8)-1;
12305 entry = &rii->cache_extent;
12306 ret = insert_cache_extent(roots_info_cache, entry);
12309 rii = container_of(entry, struct root_item_info,
12313 ASSERT(rii->cache_extent.start == root_id);
12314 ASSERT(rii->cache_extent.size == 1);
12316 if (level > rii->level || rii->level == (u8)-1) {
12317 rii->level = level;
12318 rii->bytenr = found_key.objectid;
12319 rii->gen = btrfs_extent_generation(leaf, ei);
12320 rii->node_count = 1;
12321 } else if (level == rii->level) {
12329 btrfs_release_path(&path);
12334 static int maybe_repair_root_item(struct btrfs_fs_info *info,
12335 struct btrfs_path *path,
12336 const struct btrfs_key *root_key,
12337 const int read_only_mode)
12339 const u64 root_id = root_key->objectid;
12340 struct cache_extent *entry;
12341 struct root_item_info *rii;
12342 struct btrfs_root_item ri;
12343 unsigned long offset;
12345 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12348 "Error: could not find extent items for root %llu\n",
12349 root_key->objectid);
12353 rii = container_of(entry, struct root_item_info, cache_extent);
12354 ASSERT(rii->cache_extent.start == root_id);
12355 ASSERT(rii->cache_extent.size == 1);
12357 if (rii->node_count != 1) {
12359 "Error: could not find btree root extent for root %llu\n",
12364 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12365 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12367 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12368 btrfs_root_level(&ri) != rii->level ||
12369 btrfs_root_generation(&ri) != rii->gen) {
12372 * If we're in repair mode but our caller told us to not update
12373 * the root item, i.e. just check if it needs to be updated, don't
12374 * print this message, since the caller will call us again shortly
12375 * for the same root item without read only mode (the caller will
12376 * open a transaction first).
12378 if (!(read_only_mode && repair))
12380 "%sroot item for root %llu,"
12381 " current bytenr %llu, current gen %llu, current level %u,"
12382 " new bytenr %llu, new gen %llu, new level %u\n",
12383 (read_only_mode ? "" : "fixing "),
12385 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12386 btrfs_root_level(&ri),
12387 rii->bytenr, rii->gen, rii->level);
12389 if (btrfs_root_generation(&ri) > rii->gen) {
12391 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12392 root_id, btrfs_root_generation(&ri), rii->gen);
12396 if (!read_only_mode) {
12397 btrfs_set_root_bytenr(&ri, rii->bytenr);
12398 btrfs_set_root_level(&ri, rii->level);
12399 btrfs_set_root_generation(&ri, rii->gen);
12400 write_extent_buffer(path->nodes[0], &ri,
12401 offset, sizeof(ri));
12411 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12412 * caused read-only snapshots to be corrupted if they were created at a moment
12413 * when the source subvolume/snapshot had orphan items. The issue was that the
12414 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12415 * node instead of the post orphan cleanup root node.
12416 * So this function, and its callees, just detects and fixes those cases. Even
12417 * though the regression was for read-only snapshots, this function applies to
12418 * any snapshot/subvolume root.
12419 * This must be run before any other repair code - not doing it so, makes other
12420 * repair code delete or modify backrefs in the extent tree for example, which
12421 * will result in an inconsistent fs after repairing the root items.
12423 static int repair_root_items(struct btrfs_fs_info *info)
12425 struct btrfs_path path;
12426 struct btrfs_key key;
12427 struct extent_buffer *leaf;
12428 struct btrfs_trans_handle *trans = NULL;
12431 int need_trans = 0;
12433 btrfs_init_path(&path);
12435 ret = build_roots_info_cache(info);
12439 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12440 key.type = BTRFS_ROOT_ITEM_KEY;
12445 * Avoid opening and committing transactions if a leaf doesn't have
12446 * any root items that need to be fixed, so that we avoid rotating
12447 * backup roots unnecessarily.
12450 trans = btrfs_start_transaction(info->tree_root, 1);
12451 if (IS_ERR(trans)) {
12452 ret = PTR_ERR(trans);
12457 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12461 leaf = path.nodes[0];
12464 struct btrfs_key found_key;
12466 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12467 int no_more_keys = find_next_key(&path, &key);
12469 btrfs_release_path(&path);
12471 ret = btrfs_commit_transaction(trans,
12483 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12485 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12487 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12490 ret = maybe_repair_root_item(info, &path, &found_key,
12495 if (!trans && repair) {
12498 btrfs_release_path(&path);
12508 free_roots_info_cache();
12509 btrfs_release_path(&path);
12511 btrfs_commit_transaction(trans, info->tree_root);
12518 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12520 struct btrfs_trans_handle *trans;
12521 struct btrfs_block_group_cache *bg_cache;
12525 /* Clear all free space cache inodes and its extent data */
12527 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12530 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12533 current = bg_cache->key.objectid + bg_cache->key.offset;
12536 /* Don't forget to set cache_generation to -1 */
12537 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12538 if (IS_ERR(trans)) {
12539 error("failed to update super block cache generation");
12540 return PTR_ERR(trans);
12542 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12543 btrfs_commit_transaction(trans, fs_info->tree_root);
12548 const char * const cmd_check_usage[] = {
12549 "btrfs check [options] <device>",
12550 "Check structural integrity of a filesystem (unmounted).",
12551 "Check structural integrity of an unmounted filesystem. Verify internal",
12552 "trees' consistency and item connectivity. In the repair mode try to",
12553 "fix the problems found. ",
12554 "WARNING: the repair mode is considered dangerous",
12556 "-s|--super <superblock> use this superblock copy",
12557 "-b|--backup use the first valid backup root copy",
12558 "--repair try to repair the filesystem",
12559 "--readonly run in read-only mode (default)",
12560 "--init-csum-tree create a new CRC tree",
12561 "--init-extent-tree create a new extent tree",
12562 "--mode <MODE> allows choice of memory/IO trade-offs",
12563 " where MODE is one of:",
12564 " original - read inodes and extents to memory (requires",
12565 " more memory, does less IO)",
12566 " lowmem - try to use less memory but read blocks again",
12568 "--check-data-csum verify checksums of data blocks",
12569 "-Q|--qgroup-report print a report on qgroup consistency",
12570 "-E|--subvol-extents <subvolid>",
12571 " print subvolume extents and sharing state",
12572 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12573 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12574 "-p|--progress indicate progress",
12575 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12579 int cmd_check(int argc, char **argv)
12581 struct cache_tree root_cache;
12582 struct btrfs_root *root;
12583 struct btrfs_fs_info *info;
12586 u64 tree_root_bytenr = 0;
12587 u64 chunk_root_bytenr = 0;
12588 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12592 int init_csum_tree = 0;
12594 int clear_space_cache = 0;
12595 int qgroup_report = 0;
12596 int qgroups_repaired = 0;
12597 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12601 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12602 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12603 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12604 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12605 static const struct option long_options[] = {
12606 { "super", required_argument, NULL, 's' },
12607 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12608 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12609 { "init-csum-tree", no_argument, NULL,
12610 GETOPT_VAL_INIT_CSUM },
12611 { "init-extent-tree", no_argument, NULL,
12612 GETOPT_VAL_INIT_EXTENT },
12613 { "check-data-csum", no_argument, NULL,
12614 GETOPT_VAL_CHECK_CSUM },
12615 { "backup", no_argument, NULL, 'b' },
12616 { "subvol-extents", required_argument, NULL, 'E' },
12617 { "qgroup-report", no_argument, NULL, 'Q' },
12618 { "tree-root", required_argument, NULL, 'r' },
12619 { "chunk-root", required_argument, NULL,
12620 GETOPT_VAL_CHUNK_TREE },
12621 { "progress", no_argument, NULL, 'p' },
12622 { "mode", required_argument, NULL,
12624 { "clear-space-cache", required_argument, NULL,
12625 GETOPT_VAL_CLEAR_SPACE_CACHE},
12626 { NULL, 0, NULL, 0}
12629 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
12633 case 'a': /* ignored */ break;
12635 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12638 num = arg_strtou64(optarg);
12639 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12641 "super mirror should be less than %d",
12642 BTRFS_SUPER_MIRROR_MAX);
12645 bytenr = btrfs_sb_offset(((int)num));
12646 printf("using SB copy %llu, bytenr %llu\n", num,
12647 (unsigned long long)bytenr);
12653 subvolid = arg_strtou64(optarg);
12656 tree_root_bytenr = arg_strtou64(optarg);
12658 case GETOPT_VAL_CHUNK_TREE:
12659 chunk_root_bytenr = arg_strtou64(optarg);
12662 ctx.progress_enabled = true;
12666 usage(cmd_check_usage);
12667 case GETOPT_VAL_REPAIR:
12668 printf("enabling repair mode\n");
12670 ctree_flags |= OPEN_CTREE_WRITES;
12672 case GETOPT_VAL_READONLY:
12675 case GETOPT_VAL_INIT_CSUM:
12676 printf("Creating a new CRC tree\n");
12677 init_csum_tree = 1;
12679 ctree_flags |= OPEN_CTREE_WRITES;
12681 case GETOPT_VAL_INIT_EXTENT:
12682 init_extent_tree = 1;
12683 ctree_flags |= (OPEN_CTREE_WRITES |
12684 OPEN_CTREE_NO_BLOCK_GROUPS);
12687 case GETOPT_VAL_CHECK_CSUM:
12688 check_data_csum = 1;
12690 case GETOPT_VAL_MODE:
12691 check_mode = parse_check_mode(optarg);
12692 if (check_mode == CHECK_MODE_UNKNOWN) {
12693 error("unknown mode: %s", optarg);
12697 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12698 if (strcmp(optarg, "v1") == 0) {
12699 clear_space_cache = 1;
12700 } else if (strcmp(optarg, "v2") == 0) {
12701 clear_space_cache = 2;
12702 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12705 "invalid argument to --clear-space-cache, must be v1 or v2");
12708 ctree_flags |= OPEN_CTREE_WRITES;
12713 if (check_argc_exact(argc - optind, 1))
12714 usage(cmd_check_usage);
12716 if (ctx.progress_enabled) {
12717 ctx.tp = TASK_NOTHING;
12718 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12721 /* This check is the only reason for --readonly to exist */
12722 if (readonly && repair) {
12723 error("repair options are not compatible with --readonly");
12728 * Not supported yet
12730 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12731 error("low memory mode doesn't support repair yet");
12736 cache_tree_init(&root_cache);
12738 if((ret = check_mounted(argv[optind])) < 0) {
12739 error("could not check mount status: %s", strerror(-ret));
12743 error("%s is currently mounted, aborting", argv[optind]);
12749 /* only allow partial opening under repair mode */
12751 ctree_flags |= OPEN_CTREE_PARTIAL;
12753 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12754 chunk_root_bytenr, ctree_flags);
12756 error("cannot open file system");
12762 global_info = info;
12763 root = info->fs_root;
12764 if (clear_space_cache == 1) {
12765 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12767 "free space cache v2 detected, use --clear-space-cache v2");
12771 printf("Clearing free space cache\n");
12772 ret = clear_free_space_cache(info);
12774 error("failed to clear free space cache");
12777 printf("Free space cache cleared\n");
12780 } else if (clear_space_cache == 2) {
12781 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12782 printf("no free space cache v2 to clear\n");
12786 printf("Clear free space cache v2\n");
12787 ret = btrfs_clear_free_space_tree(info);
12789 error("failed to clear free space cache v2: %d", ret);
12792 printf("free space cache v2 cleared\n");
12798 * repair mode will force us to commit transaction which
12799 * will make us fail to load log tree when mounting.
12801 if (repair && btrfs_super_log_root(info->super_copy)) {
12802 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12808 ret = zero_log_tree(root);
12811 error("failed to zero log tree: %d", ret);
12816 uuid_unparse(info->super_copy->fsid, uuidbuf);
12817 if (qgroup_report) {
12818 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12820 ret = qgroup_verify_all(info);
12827 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12828 subvolid, argv[optind], uuidbuf);
12829 ret = print_extent_state(info, subvolid);
12833 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12835 if (!extent_buffer_uptodate(info->tree_root->node) ||
12836 !extent_buffer_uptodate(info->dev_root->node) ||
12837 !extent_buffer_uptodate(info->chunk_root->node)) {
12838 error("critical roots corrupted, unable to check the filesystem");
12844 if (init_extent_tree || init_csum_tree) {
12845 struct btrfs_trans_handle *trans;
12847 trans = btrfs_start_transaction(info->extent_root, 0);
12848 if (IS_ERR(trans)) {
12849 error("error starting transaction");
12850 ret = PTR_ERR(trans);
12855 if (init_extent_tree) {
12856 printf("Creating a new extent tree\n");
12857 ret = reinit_extent_tree(trans, info);
12863 if (init_csum_tree) {
12864 printf("Reinitialize checksum tree\n");
12865 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
12867 error("checksum tree initialization failed: %d",
12874 ret = fill_csum_tree(trans, info->csum_root,
12878 error("checksum tree refilling failed: %d", ret);
12883 * Ok now we commit and run the normal fsck, which will add
12884 * extent entries for all of the items it finds.
12886 ret = btrfs_commit_transaction(trans, info->extent_root);
12891 if (!extent_buffer_uptodate(info->extent_root->node)) {
12892 error("critical: extent_root, unable to check the filesystem");
12897 if (!extent_buffer_uptodate(info->csum_root->node)) {
12898 error("critical: csum_root, unable to check the filesystem");
12904 if (!ctx.progress_enabled)
12905 fprintf(stderr, "checking extents\n");
12906 if (check_mode == CHECK_MODE_LOWMEM)
12907 ret = check_chunks_and_extents_v2(root);
12909 ret = check_chunks_and_extents(root);
12913 "errors found in extent allocation tree or chunk allocation");
12915 ret = repair_root_items(info);
12920 fprintf(stderr, "Fixed %d roots.\n", ret);
12922 } else if (ret > 0) {
12924 "Found %d roots with an outdated root item.\n",
12927 "Please run a filesystem check with the option --repair to fix them.\n");
12933 if (!ctx.progress_enabled) {
12934 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12935 fprintf(stderr, "checking free space tree\n");
12937 fprintf(stderr, "checking free space cache\n");
12939 ret = check_space_cache(root);
12945 * We used to have to have these hole extents in between our real
12946 * extents so if we don't have this flag set we need to make sure there
12947 * are no gaps in the file extents for inodes, otherwise we can just
12948 * ignore it when this happens.
12950 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
12951 if (!ctx.progress_enabled)
12952 fprintf(stderr, "checking fs roots\n");
12953 if (check_mode == CHECK_MODE_LOWMEM)
12954 ret = check_fs_roots_v2(root->fs_info);
12956 ret = check_fs_roots(root, &root_cache);
12961 fprintf(stderr, "checking csums\n");
12962 ret = check_csums(root);
12967 fprintf(stderr, "checking root refs\n");
12968 /* For low memory mode, check_fs_roots_v2 handles root refs */
12969 if (check_mode != CHECK_MODE_LOWMEM) {
12970 ret = check_root_refs(root, &root_cache);
12976 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
12977 struct extent_buffer *eb;
12979 eb = list_first_entry(&root->fs_info->recow_ebs,
12980 struct extent_buffer, recow);
12981 list_del_init(&eb->recow);
12982 ret = recow_extent_buffer(root, eb);
12988 while (!list_empty(&delete_items)) {
12989 struct bad_item *bad;
12991 bad = list_first_entry(&delete_items, struct bad_item, list);
12992 list_del_init(&bad->list);
12994 ret = delete_bad_item(root, bad);
13000 if (info->quota_enabled) {
13001 fprintf(stderr, "checking quota groups\n");
13002 ret = qgroup_verify_all(info);
13007 ret = repair_qgroups(info, &qgroups_repaired);
13014 if (!list_empty(&root->fs_info->recow_ebs)) {
13015 error("transid errors in file system");
13020 if (found_old_backref) { /*
13021 * there was a disk format change when mixed
13022 * backref was in testing tree. The old format
13023 * existed about one week.
13025 printf("\n * Found old mixed backref format. "
13026 "The old format is not supported! *"
13027 "\n * Please mount the FS in readonly mode, "
13028 "backup data and re-format the FS. *\n\n");
13031 printf("found %llu bytes used err is %d\n",
13032 (unsigned long long)bytes_used, ret);
13033 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
13034 printf("total tree bytes: %llu\n",
13035 (unsigned long long)total_btree_bytes);
13036 printf("total fs tree bytes: %llu\n",
13037 (unsigned long long)total_fs_tree_bytes);
13038 printf("total extent tree bytes: %llu\n",
13039 (unsigned long long)total_extent_tree_bytes);
13040 printf("btree space waste bytes: %llu\n",
13041 (unsigned long long)btree_space_waste);
13042 printf("file data blocks allocated: %llu\n referenced %llu\n",
13043 (unsigned long long)data_bytes_allocated,
13044 (unsigned long long)data_bytes_referenced);
13046 free_qgroup_counts();
13047 free_root_recs_tree(&root_cache);
13051 if (ctx.progress_enabled)
13052 task_deinit(ctx.info);