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,
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, 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, 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 u64 csum_found; /* In byte size, sectorsize aligned */
4704 u64 search_start; /* Logical range start we search for csum */
4705 u64 search_len; /* Logical range len we search for csum */
4706 unsigned int extent_type;
4707 unsigned int is_hole;
4712 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4714 extent_type = btrfs_file_extent_type(node, fi);
4715 /* Skip if file extent is inline */
4716 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4717 struct btrfs_item *e = btrfs_item_nr(slot);
4718 u32 item_inline_len;
4720 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4721 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4722 if (extent_num_bytes == 0 ||
4723 extent_num_bytes != item_inline_len)
4724 err |= FILE_EXTENT_ERROR;
4725 *size += extent_num_bytes;
4729 /* Check extent type */
4730 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4731 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4732 err |= FILE_EXTENT_ERROR;
4733 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4734 root->objectid, fkey->objectid, fkey->offset);
4738 /* Check REG_EXTENT/PREALLOC_EXTENT */
4739 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4740 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4741 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4742 extent_offset = btrfs_file_extent_offset(node, fi);
4743 compressed = btrfs_file_extent_compression(node, fi);
4744 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4747 * Check EXTENT_DATA csum
4749 * For plain (uncompressed) extent, we should only check the range
4750 * we're referring to, as it's possible that part of prealloc extent
4751 * has been written, and has csum:
4753 * |<--- Original large preallocated extent A ---->|
4754 * |<- Prealloc File Extent ->|<- Regular Extent ->|
4757 * For compressed extent, we should check the whole range.
4760 search_start = disk_bytenr + extent_offset;
4761 search_len = extent_num_bytes;
4763 search_start = disk_bytenr;
4764 search_len = disk_num_bytes;
4766 ret = count_csum_range(root, search_start, search_len, &csum_found);
4767 if (csum_found > 0 && nodatasum) {
4768 err |= ODD_CSUM_ITEM;
4769 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4770 root->objectid, fkey->objectid, fkey->offset);
4771 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4772 !is_hole && (ret < 0 || csum_found < search_len)) {
4773 err |= CSUM_ITEM_MISSING;
4774 error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
4775 root->objectid, fkey->objectid, fkey->offset,
4776 csum_found, search_len);
4777 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
4778 err |= ODD_CSUM_ITEM;
4779 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
4780 root->objectid, fkey->objectid, fkey->offset, csum_found);
4783 /* Check EXTENT_DATA hole */
4784 if (no_holes && is_hole) {
4785 err |= FILE_EXTENT_ERROR;
4786 error("root %llu EXTENT_DATA[%llu %llu] shouldn't be hole",
4787 root->objectid, fkey->objectid, fkey->offset);
4788 } else if (!no_holes && *end != fkey->offset) {
4789 err |= FILE_EXTENT_ERROR;
4790 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4791 root->objectid, fkey->objectid, fkey->offset);
4794 *end += extent_num_bytes;
4796 *size += extent_num_bytes;
4802 * Check INODE_ITEM and related ITEMs (the same inode number)
4803 * 1. check link count
4804 * 2. check inode ref/extref
4805 * 3. check dir item/index
4807 * @ext_ref: the EXTENDED_IREF feature
4809 * Return 0 if no error occurred.
4810 * Return >0 for error or hit the traversal is done(by error bitmap)
4812 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4813 unsigned int ext_ref)
4815 struct extent_buffer *node;
4816 struct btrfs_inode_item *ii;
4817 struct btrfs_key key;
4826 u64 extent_size = 0;
4828 unsigned int nodatasum;
4833 node = path->nodes[0];
4834 slot = path->slots[0];
4836 btrfs_item_key_to_cpu(node, &key, slot);
4837 inode_id = key.objectid;
4839 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4840 ret = btrfs_next_item(root, path);
4846 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4847 isize = btrfs_inode_size(node, ii);
4848 nbytes = btrfs_inode_nbytes(node, ii);
4849 mode = btrfs_inode_mode(node, ii);
4850 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4851 nlink = btrfs_inode_nlink(node, ii);
4852 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4855 ret = btrfs_next_item(root, path);
4857 /* out will fill 'err' rusing current statistics */
4859 } else if (ret > 0) {
4864 node = path->nodes[0];
4865 slot = path->slots[0];
4866 btrfs_item_key_to_cpu(node, &key, slot);
4867 if (key.objectid != inode_id)
4871 case BTRFS_INODE_REF_KEY:
4872 ret = check_inode_ref(root, &key, node, slot, &refs,
4876 case BTRFS_INODE_EXTREF_KEY:
4877 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4878 warning("root %llu EXTREF[%llu %llu] isn't supported",
4879 root->objectid, key.objectid,
4881 ret = check_inode_extref(root, &key, node, slot, &refs,
4885 case BTRFS_DIR_ITEM_KEY:
4886 case BTRFS_DIR_INDEX_KEY:
4888 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4889 root->objectid, inode_id,
4890 imode_to_type(mode), key.objectid,
4893 ret = check_dir_item(root, &key, node, slot, &size,
4897 case BTRFS_EXTENT_DATA_KEY:
4899 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4900 root->objectid, inode_id, key.objectid,
4903 ret = check_file_extent(root, &key, node, slot,
4904 nodatasum, &extent_size,
4908 case BTRFS_XATTR_ITEM_KEY:
4911 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4912 key.objectid, key.type, key.offset);
4917 /* verify INODE_ITEM nlink/isize/nbytes */
4920 err |= LINK_COUNT_ERROR;
4921 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4922 root->objectid, inode_id, nlink);
4926 * Just a warning, as dir inode nbytes is just an
4927 * instructive value.
4929 if (!IS_ALIGNED(nbytes, root->nodesize)) {
4930 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
4931 root->objectid, inode_id, root->nodesize);
4934 if (isize != size) {
4936 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
4937 root->objectid, inode_id, isize, size);
4940 if (nlink != refs) {
4941 err |= LINK_COUNT_ERROR;
4942 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
4943 root->objectid, inode_id, nlink, refs);
4944 } else if (!nlink) {
4948 if (!nbytes && !no_holes && extent_end < isize) {
4949 err |= NBYTES_ERROR;
4950 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
4951 root->objectid, inode_id, isize);
4954 if (nbytes != extent_size) {
4955 err |= NBYTES_ERROR;
4956 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
4957 root->objectid, inode_id, nbytes, extent_size);
4964 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4966 struct btrfs_path path;
4967 struct btrfs_key key;
4971 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4972 key.type = BTRFS_INODE_ITEM_KEY;
4975 /* For root being dropped, we don't need to check first inode */
4976 if (btrfs_root_refs(&root->root_item) == 0 &&
4977 btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
4981 btrfs_init_path(&path);
4983 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4988 err |= INODE_ITEM_MISSING;
4991 err |= check_inode_item(root, &path, ext_ref);
4996 btrfs_release_path(&path);
5001 * Iterate all item on the tree and call check_inode_item() to check.
5003 * @root: the root of the tree to be checked.
5004 * @ext_ref: the EXTENDED_IREF feature
5006 * Return 0 if no error found.
5007 * Return <0 for error.
5009 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
5011 struct btrfs_path path;
5012 struct node_refs nrefs;
5013 struct btrfs_root_item *root_item = &root->root_item;
5018 * We need to manually check the first inode item(256)
5019 * As the following traversal function will only start from
5020 * the first inode item in the leaf, if inode item(256) is missing
5021 * we will just skip it forever.
5023 ret = check_fs_first_inode(root, ext_ref);
5027 memset(&nrefs, 0, sizeof(nrefs));
5028 level = btrfs_header_level(root->node);
5029 btrfs_init_path(&path);
5031 if (btrfs_root_refs(root_item) > 0 ||
5032 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5033 path.nodes[level] = root->node;
5034 path.slots[level] = 0;
5035 extent_buffer_get(root->node);
5037 struct btrfs_key key;
5039 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5040 level = root_item->drop_level;
5041 path.lowest_level = level;
5042 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5049 wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5055 wret = walk_up_tree_v2(root, &path, &level);
5063 btrfs_release_path(&path);
5068 * Find the relative ref for root_ref and root_backref.
5070 * @root: the root of the root tree.
5071 * @ref_key: the key of the root ref.
5073 * Return 0 if no error occurred.
5075 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5076 struct extent_buffer *node, int slot)
5078 struct btrfs_path path;
5079 struct btrfs_key key;
5080 struct btrfs_root_ref *ref;
5081 struct btrfs_root_ref *backref;
5082 char ref_name[BTRFS_NAME_LEN] = {0};
5083 char backref_name[BTRFS_NAME_LEN] = {0};
5089 u32 backref_namelen;
5094 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5095 ref_dirid = btrfs_root_ref_dirid(node, ref);
5096 ref_seq = btrfs_root_ref_sequence(node, ref);
5097 ref_namelen = btrfs_root_ref_name_len(node, ref);
5099 if (ref_namelen <= BTRFS_NAME_LEN) {
5102 len = BTRFS_NAME_LEN;
5103 warning("%s[%llu %llu] ref_name too long",
5104 ref_key->type == BTRFS_ROOT_REF_KEY ?
5105 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5108 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5110 /* Find relative root_ref */
5111 key.objectid = ref_key->offset;
5112 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5113 key.offset = ref_key->objectid;
5115 btrfs_init_path(&path);
5116 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5118 err |= ROOT_REF_MISSING;
5119 error("%s[%llu %llu] couldn't find relative ref",
5120 ref_key->type == BTRFS_ROOT_REF_KEY ?
5121 "ROOT_REF" : "ROOT_BACKREF",
5122 ref_key->objectid, ref_key->offset);
5126 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5127 struct btrfs_root_ref);
5128 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5129 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5130 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5132 if (backref_namelen <= BTRFS_NAME_LEN) {
5133 len = backref_namelen;
5135 len = BTRFS_NAME_LEN;
5136 warning("%s[%llu %llu] ref_name too long",
5137 key.type == BTRFS_ROOT_REF_KEY ?
5138 "ROOT_REF" : "ROOT_BACKREF",
5139 key.objectid, key.offset);
5141 read_extent_buffer(path.nodes[0], backref_name,
5142 (unsigned long)(backref + 1), len);
5144 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5145 ref_namelen != backref_namelen ||
5146 strncmp(ref_name, backref_name, len)) {
5147 err |= ROOT_REF_MISMATCH;
5148 error("%s[%llu %llu] mismatch relative ref",
5149 ref_key->type == BTRFS_ROOT_REF_KEY ?
5150 "ROOT_REF" : "ROOT_BACKREF",
5151 ref_key->objectid, ref_key->offset);
5154 btrfs_release_path(&path);
5159 * Check all fs/file tree in low_memory mode.
5161 * 1. for fs tree root item, call check_fs_root_v2()
5162 * 2. for fs tree root ref/backref, call check_root_ref()
5164 * Return 0 if no error occurred.
5166 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5168 struct btrfs_root *tree_root = fs_info->tree_root;
5169 struct btrfs_root *cur_root = NULL;
5170 struct btrfs_path path;
5171 struct btrfs_key key;
5172 struct extent_buffer *node;
5173 unsigned int ext_ref;
5178 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5180 btrfs_init_path(&path);
5181 key.objectid = BTRFS_FS_TREE_OBJECTID;
5183 key.type = BTRFS_ROOT_ITEM_KEY;
5185 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5189 } else if (ret > 0) {
5195 node = path.nodes[0];
5196 slot = path.slots[0];
5197 btrfs_item_key_to_cpu(node, &key, slot);
5198 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5200 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5201 fs_root_objectid(key.objectid)) {
5202 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5203 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5206 key.offset = (u64)-1;
5207 cur_root = btrfs_read_fs_root(fs_info, &key);
5210 if (IS_ERR(cur_root)) {
5211 error("Fail to read fs/subvol tree: %lld",
5217 ret = check_fs_root_v2(cur_root, ext_ref);
5220 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5221 btrfs_free_fs_root(cur_root);
5222 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5223 key.type == BTRFS_ROOT_BACKREF_KEY) {
5224 ret = check_root_ref(tree_root, &key, node, slot);
5228 ret = btrfs_next_item(tree_root, &path);
5238 btrfs_release_path(&path);
5242 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5244 struct list_head *cur = rec->backrefs.next;
5245 struct extent_backref *back;
5246 struct tree_backref *tback;
5247 struct data_backref *dback;
5251 while(cur != &rec->backrefs) {
5252 back = to_extent_backref(cur);
5254 if (!back->found_extent_tree) {
5258 if (back->is_data) {
5259 dback = to_data_backref(back);
5260 fprintf(stderr, "Backref %llu %s %llu"
5261 " owner %llu offset %llu num_refs %lu"
5262 " not found in extent tree\n",
5263 (unsigned long long)rec->start,
5264 back->full_backref ?
5266 back->full_backref ?
5267 (unsigned long long)dback->parent:
5268 (unsigned long long)dback->root,
5269 (unsigned long long)dback->owner,
5270 (unsigned long long)dback->offset,
5271 (unsigned long)dback->num_refs);
5273 tback = to_tree_backref(back);
5274 fprintf(stderr, "Backref %llu parent %llu"
5275 " root %llu not found in extent tree\n",
5276 (unsigned long long)rec->start,
5277 (unsigned long long)tback->parent,
5278 (unsigned long long)tback->root);
5281 if (!back->is_data && !back->found_ref) {
5285 tback = to_tree_backref(back);
5286 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5287 (unsigned long long)rec->start,
5288 back->full_backref ? "parent" : "root",
5289 back->full_backref ?
5290 (unsigned long long)tback->parent :
5291 (unsigned long long)tback->root, back);
5293 if (back->is_data) {
5294 dback = to_data_backref(back);
5295 if (dback->found_ref != dback->num_refs) {
5299 fprintf(stderr, "Incorrect local backref count"
5300 " on %llu %s %llu owner %llu"
5301 " offset %llu found %u wanted %u back %p\n",
5302 (unsigned long long)rec->start,
5303 back->full_backref ?
5305 back->full_backref ?
5306 (unsigned long long)dback->parent:
5307 (unsigned long long)dback->root,
5308 (unsigned long long)dback->owner,
5309 (unsigned long long)dback->offset,
5310 dback->found_ref, dback->num_refs, back);
5312 if (dback->disk_bytenr != rec->start) {
5316 fprintf(stderr, "Backref disk bytenr does not"
5317 " match extent record, bytenr=%llu, "
5318 "ref bytenr=%llu\n",
5319 (unsigned long long)rec->start,
5320 (unsigned long long)dback->disk_bytenr);
5323 if (dback->bytes != rec->nr) {
5327 fprintf(stderr, "Backref bytes do not match "
5328 "extent backref, bytenr=%llu, ref "
5329 "bytes=%llu, backref bytes=%llu\n",
5330 (unsigned long long)rec->start,
5331 (unsigned long long)rec->nr,
5332 (unsigned long long)dback->bytes);
5335 if (!back->is_data) {
5338 dback = to_data_backref(back);
5339 found += dback->found_ref;
5342 if (found != rec->refs) {
5346 fprintf(stderr, "Incorrect global backref count "
5347 "on %llu found %llu wanted %llu\n",
5348 (unsigned long long)rec->start,
5349 (unsigned long long)found,
5350 (unsigned long long)rec->refs);
5356 static int free_all_extent_backrefs(struct extent_record *rec)
5358 struct extent_backref *back;
5359 struct list_head *cur;
5360 while (!list_empty(&rec->backrefs)) {
5361 cur = rec->backrefs.next;
5362 back = to_extent_backref(cur);
5369 static void free_extent_record_cache(struct cache_tree *extent_cache)
5371 struct cache_extent *cache;
5372 struct extent_record *rec;
5375 cache = first_cache_extent(extent_cache);
5378 rec = container_of(cache, struct extent_record, cache);
5379 remove_cache_extent(extent_cache, cache);
5380 free_all_extent_backrefs(rec);
5385 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5386 struct extent_record *rec)
5388 if (rec->content_checked && rec->owner_ref_checked &&
5389 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5390 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5391 !rec->bad_full_backref && !rec->crossing_stripes &&
5392 !rec->wrong_chunk_type) {
5393 remove_cache_extent(extent_cache, &rec->cache);
5394 free_all_extent_backrefs(rec);
5395 list_del_init(&rec->list);
5401 static int check_owner_ref(struct btrfs_root *root,
5402 struct extent_record *rec,
5403 struct extent_buffer *buf)
5405 struct extent_backref *node;
5406 struct tree_backref *back;
5407 struct btrfs_root *ref_root;
5408 struct btrfs_key key;
5409 struct btrfs_path path;
5410 struct extent_buffer *parent;
5415 list_for_each_entry(node, &rec->backrefs, list) {
5418 if (!node->found_ref)
5420 if (node->full_backref)
5422 back = to_tree_backref(node);
5423 if (btrfs_header_owner(buf) == back->root)
5426 BUG_ON(rec->is_root);
5428 /* try to find the block by search corresponding fs tree */
5429 key.objectid = btrfs_header_owner(buf);
5430 key.type = BTRFS_ROOT_ITEM_KEY;
5431 key.offset = (u64)-1;
5433 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5434 if (IS_ERR(ref_root))
5437 level = btrfs_header_level(buf);
5439 btrfs_item_key_to_cpu(buf, &key, 0);
5441 btrfs_node_key_to_cpu(buf, &key, 0);
5443 btrfs_init_path(&path);
5444 path.lowest_level = level + 1;
5445 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5449 parent = path.nodes[level + 1];
5450 if (parent && buf->start == btrfs_node_blockptr(parent,
5451 path.slots[level + 1]))
5454 btrfs_release_path(&path);
5455 return found ? 0 : 1;
5458 static int is_extent_tree_record(struct extent_record *rec)
5460 struct list_head *cur = rec->backrefs.next;
5461 struct extent_backref *node;
5462 struct tree_backref *back;
5465 while(cur != &rec->backrefs) {
5466 node = to_extent_backref(cur);
5470 back = to_tree_backref(node);
5471 if (node->full_backref)
5473 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5480 static int record_bad_block_io(struct btrfs_fs_info *info,
5481 struct cache_tree *extent_cache,
5484 struct extent_record *rec;
5485 struct cache_extent *cache;
5486 struct btrfs_key key;
5488 cache = lookup_cache_extent(extent_cache, start, len);
5492 rec = container_of(cache, struct extent_record, cache);
5493 if (!is_extent_tree_record(rec))
5496 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5497 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5500 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5501 struct extent_buffer *buf, int slot)
5503 if (btrfs_header_level(buf)) {
5504 struct btrfs_key_ptr ptr1, ptr2;
5506 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5507 sizeof(struct btrfs_key_ptr));
5508 read_extent_buffer(buf, &ptr2,
5509 btrfs_node_key_ptr_offset(slot + 1),
5510 sizeof(struct btrfs_key_ptr));
5511 write_extent_buffer(buf, &ptr1,
5512 btrfs_node_key_ptr_offset(slot + 1),
5513 sizeof(struct btrfs_key_ptr));
5514 write_extent_buffer(buf, &ptr2,
5515 btrfs_node_key_ptr_offset(slot),
5516 sizeof(struct btrfs_key_ptr));
5518 struct btrfs_disk_key key;
5519 btrfs_node_key(buf, &key, 0);
5520 btrfs_fixup_low_keys(root, path, &key,
5521 btrfs_header_level(buf) + 1);
5524 struct btrfs_item *item1, *item2;
5525 struct btrfs_key k1, k2;
5526 char *item1_data, *item2_data;
5527 u32 item1_offset, item2_offset, item1_size, item2_size;
5529 item1 = btrfs_item_nr(slot);
5530 item2 = btrfs_item_nr(slot + 1);
5531 btrfs_item_key_to_cpu(buf, &k1, slot);
5532 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5533 item1_offset = btrfs_item_offset(buf, item1);
5534 item2_offset = btrfs_item_offset(buf, item2);
5535 item1_size = btrfs_item_size(buf, item1);
5536 item2_size = btrfs_item_size(buf, item2);
5538 item1_data = malloc(item1_size);
5541 item2_data = malloc(item2_size);
5547 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5548 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5550 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5551 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5555 btrfs_set_item_offset(buf, item1, item2_offset);
5556 btrfs_set_item_offset(buf, item2, item1_offset);
5557 btrfs_set_item_size(buf, item1, item2_size);
5558 btrfs_set_item_size(buf, item2, item1_size);
5560 path->slots[0] = slot;
5561 btrfs_set_item_key_unsafe(root, path, &k2);
5562 path->slots[0] = slot + 1;
5563 btrfs_set_item_key_unsafe(root, path, &k1);
5568 static int fix_key_order(struct btrfs_root *root, struct btrfs_path *path)
5570 struct extent_buffer *buf;
5571 struct btrfs_key k1, k2;
5573 int level = path->lowest_level;
5576 buf = path->nodes[level];
5577 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5579 btrfs_node_key_to_cpu(buf, &k1, i);
5580 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5582 btrfs_item_key_to_cpu(buf, &k1, i);
5583 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5585 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5587 ret = swap_values(root, path, buf, i);
5590 btrfs_mark_buffer_dirty(buf);
5596 static int delete_bogus_item(struct btrfs_root *root,
5597 struct btrfs_path *path,
5598 struct extent_buffer *buf, int slot)
5600 struct btrfs_key key;
5601 int nritems = btrfs_header_nritems(buf);
5603 btrfs_item_key_to_cpu(buf, &key, slot);
5605 /* These are all the keys we can deal with missing. */
5606 if (key.type != BTRFS_DIR_INDEX_KEY &&
5607 key.type != BTRFS_EXTENT_ITEM_KEY &&
5608 key.type != BTRFS_METADATA_ITEM_KEY &&
5609 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5610 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5613 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5614 (unsigned long long)key.objectid, key.type,
5615 (unsigned long long)key.offset, slot, buf->start);
5616 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5617 btrfs_item_nr_offset(slot + 1),
5618 sizeof(struct btrfs_item) *
5619 (nritems - slot - 1));
5620 btrfs_set_header_nritems(buf, nritems - 1);
5622 struct btrfs_disk_key disk_key;
5624 btrfs_item_key(buf, &disk_key, 0);
5625 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5627 btrfs_mark_buffer_dirty(buf);
5631 static int fix_item_offset(struct btrfs_root *root, struct btrfs_path *path)
5633 struct extent_buffer *buf;
5637 /* We should only get this for leaves */
5638 BUG_ON(path->lowest_level);
5639 buf = path->nodes[0];
5641 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5642 unsigned int shift = 0, offset;
5644 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5645 BTRFS_LEAF_DATA_SIZE(root)) {
5646 if (btrfs_item_end_nr(buf, i) >
5647 BTRFS_LEAF_DATA_SIZE(root)) {
5648 ret = delete_bogus_item(root, path, buf, i);
5651 fprintf(stderr, "item is off the end of the "
5652 "leaf, can't fix\n");
5656 shift = BTRFS_LEAF_DATA_SIZE(root) -
5657 btrfs_item_end_nr(buf, i);
5658 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5659 btrfs_item_offset_nr(buf, i - 1)) {
5660 if (btrfs_item_end_nr(buf, i) >
5661 btrfs_item_offset_nr(buf, i - 1)) {
5662 ret = delete_bogus_item(root, path, buf, i);
5665 fprintf(stderr, "items overlap, can't fix\n");
5669 shift = btrfs_item_offset_nr(buf, i - 1) -
5670 btrfs_item_end_nr(buf, i);
5675 printf("Shifting item nr %d by %u bytes in block %llu\n",
5676 i, shift, (unsigned long long)buf->start);
5677 offset = btrfs_item_offset_nr(buf, i);
5678 memmove_extent_buffer(buf,
5679 btrfs_leaf_data(buf) + offset + shift,
5680 btrfs_leaf_data(buf) + offset,
5681 btrfs_item_size_nr(buf, i));
5682 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5684 btrfs_mark_buffer_dirty(buf);
5688 * We may have moved things, in which case we want to exit so we don't
5689 * write those changes out. Once we have proper abort functionality in
5690 * progs this can be changed to something nicer.
5697 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5698 * then just return -EIO.
5700 static int try_to_fix_bad_block(struct btrfs_root *root,
5701 struct extent_buffer *buf,
5702 enum btrfs_tree_block_status status)
5704 struct btrfs_trans_handle *trans;
5705 struct ulist *roots;
5706 struct ulist_node *node;
5707 struct btrfs_root *search_root;
5708 struct btrfs_path path;
5709 struct ulist_iterator iter;
5710 struct btrfs_key root_key, key;
5713 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5714 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5717 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5721 btrfs_init_path(&path);
5722 ULIST_ITER_INIT(&iter);
5723 while ((node = ulist_next(roots, &iter))) {
5724 root_key.objectid = node->val;
5725 root_key.type = BTRFS_ROOT_ITEM_KEY;
5726 root_key.offset = (u64)-1;
5728 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5735 trans = btrfs_start_transaction(search_root, 0);
5736 if (IS_ERR(trans)) {
5737 ret = PTR_ERR(trans);
5741 path.lowest_level = btrfs_header_level(buf);
5742 path.skip_check_block = 1;
5743 if (path.lowest_level)
5744 btrfs_node_key_to_cpu(buf, &key, 0);
5746 btrfs_item_key_to_cpu(buf, &key, 0);
5747 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5750 btrfs_commit_transaction(trans, search_root);
5753 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5754 ret = fix_key_order(search_root, &path);
5755 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5756 ret = fix_item_offset(search_root, &path);
5758 btrfs_commit_transaction(trans, search_root);
5761 btrfs_release_path(&path);
5762 btrfs_commit_transaction(trans, search_root);
5765 btrfs_release_path(&path);
5769 static int check_block(struct btrfs_root *root,
5770 struct cache_tree *extent_cache,
5771 struct extent_buffer *buf, u64 flags)
5773 struct extent_record *rec;
5774 struct cache_extent *cache;
5775 struct btrfs_key key;
5776 enum btrfs_tree_block_status status;
5780 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5783 rec = container_of(cache, struct extent_record, cache);
5784 rec->generation = btrfs_header_generation(buf);
5786 level = btrfs_header_level(buf);
5787 if (btrfs_header_nritems(buf) > 0) {
5790 btrfs_item_key_to_cpu(buf, &key, 0);
5792 btrfs_node_key_to_cpu(buf, &key, 0);
5794 rec->info_objectid = key.objectid;
5796 rec->info_level = level;
5798 if (btrfs_is_leaf(buf))
5799 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5801 status = btrfs_check_node(root, &rec->parent_key, buf);
5803 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5805 status = try_to_fix_bad_block(root, buf, status);
5806 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5808 fprintf(stderr, "bad block %llu\n",
5809 (unsigned long long)buf->start);
5812 * Signal to callers we need to start the scan over
5813 * again since we'll have cowed blocks.
5818 rec->content_checked = 1;
5819 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5820 rec->owner_ref_checked = 1;
5822 ret = check_owner_ref(root, rec, buf);
5824 rec->owner_ref_checked = 1;
5828 maybe_free_extent_rec(extent_cache, rec);
5832 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5833 u64 parent, u64 root)
5835 struct list_head *cur = rec->backrefs.next;
5836 struct extent_backref *node;
5837 struct tree_backref *back;
5839 while(cur != &rec->backrefs) {
5840 node = to_extent_backref(cur);
5844 back = to_tree_backref(node);
5846 if (!node->full_backref)
5848 if (parent == back->parent)
5851 if (node->full_backref)
5853 if (back->root == root)
5860 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5861 u64 parent, u64 root)
5863 struct tree_backref *ref = malloc(sizeof(*ref));
5867 memset(&ref->node, 0, sizeof(ref->node));
5869 ref->parent = parent;
5870 ref->node.full_backref = 1;
5873 ref->node.full_backref = 0;
5875 list_add_tail(&ref->node.list, &rec->backrefs);
5880 static struct data_backref *find_data_backref(struct extent_record *rec,
5881 u64 parent, u64 root,
5882 u64 owner, u64 offset,
5884 u64 disk_bytenr, u64 bytes)
5886 struct list_head *cur = rec->backrefs.next;
5887 struct extent_backref *node;
5888 struct data_backref *back;
5890 while(cur != &rec->backrefs) {
5891 node = to_extent_backref(cur);
5895 back = to_data_backref(node);
5897 if (!node->full_backref)
5899 if (parent == back->parent)
5902 if (node->full_backref)
5904 if (back->root == root && back->owner == owner &&
5905 back->offset == offset) {
5906 if (found_ref && node->found_ref &&
5907 (back->bytes != bytes ||
5908 back->disk_bytenr != disk_bytenr))
5917 static struct data_backref *alloc_data_backref(struct extent_record *rec,
5918 u64 parent, u64 root,
5919 u64 owner, u64 offset,
5922 struct data_backref *ref = malloc(sizeof(*ref));
5926 memset(&ref->node, 0, sizeof(ref->node));
5927 ref->node.is_data = 1;
5930 ref->parent = parent;
5933 ref->node.full_backref = 1;
5937 ref->offset = offset;
5938 ref->node.full_backref = 0;
5940 ref->bytes = max_size;
5943 list_add_tail(&ref->node.list, &rec->backrefs);
5944 if (max_size > rec->max_size)
5945 rec->max_size = max_size;
5949 /* Check if the type of extent matches with its chunk */
5950 static void check_extent_type(struct extent_record *rec)
5952 struct btrfs_block_group_cache *bg_cache;
5954 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
5958 /* data extent, check chunk directly*/
5959 if (!rec->metadata) {
5960 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
5961 rec->wrong_chunk_type = 1;
5965 /* metadata extent, check the obvious case first */
5966 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
5967 BTRFS_BLOCK_GROUP_METADATA))) {
5968 rec->wrong_chunk_type = 1;
5973 * Check SYSTEM extent, as it's also marked as metadata, we can only
5974 * make sure it's a SYSTEM extent by its backref
5976 if (!list_empty(&rec->backrefs)) {
5977 struct extent_backref *node;
5978 struct tree_backref *tback;
5981 node = to_extent_backref(rec->backrefs.next);
5982 if (node->is_data) {
5983 /* tree block shouldn't have data backref */
5984 rec->wrong_chunk_type = 1;
5987 tback = container_of(node, struct tree_backref, node);
5989 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
5990 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
5992 bg_type = BTRFS_BLOCK_GROUP_METADATA;
5993 if (!(bg_cache->flags & bg_type))
5994 rec->wrong_chunk_type = 1;
5999 * Allocate a new extent record, fill default values from @tmpl and insert int
6000 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
6001 * the cache, otherwise it fails.
6003 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
6004 struct extent_record *tmpl)
6006 struct extent_record *rec;
6009 rec = malloc(sizeof(*rec));
6012 rec->start = tmpl->start;
6013 rec->max_size = tmpl->max_size;
6014 rec->nr = max(tmpl->nr, tmpl->max_size);
6015 rec->found_rec = tmpl->found_rec;
6016 rec->content_checked = tmpl->content_checked;
6017 rec->owner_ref_checked = tmpl->owner_ref_checked;
6018 rec->num_duplicates = 0;
6019 rec->metadata = tmpl->metadata;
6020 rec->flag_block_full_backref = FLAG_UNSET;
6021 rec->bad_full_backref = 0;
6022 rec->crossing_stripes = 0;
6023 rec->wrong_chunk_type = 0;
6024 rec->is_root = tmpl->is_root;
6025 rec->refs = tmpl->refs;
6026 rec->extent_item_refs = tmpl->extent_item_refs;
6027 rec->parent_generation = tmpl->parent_generation;
6028 INIT_LIST_HEAD(&rec->backrefs);
6029 INIT_LIST_HEAD(&rec->dups);
6030 INIT_LIST_HEAD(&rec->list);
6031 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6032 rec->cache.start = tmpl->start;
6033 rec->cache.size = tmpl->nr;
6034 ret = insert_cache_extent(extent_cache, &rec->cache);
6039 bytes_used += rec->nr;
6042 rec->crossing_stripes = check_crossing_stripes(global_info,
6043 rec->start, global_info->tree_root->nodesize);
6044 check_extent_type(rec);
6049 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6051 * - refs - if found, increase refs
6052 * - is_root - if found, set
6053 * - content_checked - if found, set
6054 * - owner_ref_checked - if found, set
6056 * If not found, create a new one, initialize and insert.
6058 static int add_extent_rec(struct cache_tree *extent_cache,
6059 struct extent_record *tmpl)
6061 struct extent_record *rec;
6062 struct cache_extent *cache;
6066 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6068 rec = container_of(cache, struct extent_record, cache);
6072 rec->nr = max(tmpl->nr, tmpl->max_size);
6075 * We need to make sure to reset nr to whatever the extent
6076 * record says was the real size, this way we can compare it to
6079 if (tmpl->found_rec) {
6080 if (tmpl->start != rec->start || rec->found_rec) {
6081 struct extent_record *tmp;
6084 if (list_empty(&rec->list))
6085 list_add_tail(&rec->list,
6086 &duplicate_extents);
6089 * We have to do this song and dance in case we
6090 * find an extent record that falls inside of
6091 * our current extent record but does not have
6092 * the same objectid.
6094 tmp = malloc(sizeof(*tmp));
6097 tmp->start = tmpl->start;
6098 tmp->max_size = tmpl->max_size;
6101 tmp->metadata = tmpl->metadata;
6102 tmp->extent_item_refs = tmpl->extent_item_refs;
6103 INIT_LIST_HEAD(&tmp->list);
6104 list_add_tail(&tmp->list, &rec->dups);
6105 rec->num_duplicates++;
6112 if (tmpl->extent_item_refs && !dup) {
6113 if (rec->extent_item_refs) {
6114 fprintf(stderr, "block %llu rec "
6115 "extent_item_refs %llu, passed %llu\n",
6116 (unsigned long long)tmpl->start,
6117 (unsigned long long)
6118 rec->extent_item_refs,
6119 (unsigned long long)tmpl->extent_item_refs);
6121 rec->extent_item_refs = tmpl->extent_item_refs;
6125 if (tmpl->content_checked)
6126 rec->content_checked = 1;
6127 if (tmpl->owner_ref_checked)
6128 rec->owner_ref_checked = 1;
6129 memcpy(&rec->parent_key, &tmpl->parent_key,
6130 sizeof(tmpl->parent_key));
6131 if (tmpl->parent_generation)
6132 rec->parent_generation = tmpl->parent_generation;
6133 if (rec->max_size < tmpl->max_size)
6134 rec->max_size = tmpl->max_size;
6137 * A metadata extent can't cross stripe_len boundary, otherwise
6138 * kernel scrub won't be able to handle it.
6139 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6143 rec->crossing_stripes = check_crossing_stripes(
6144 global_info, rec->start,
6145 global_info->tree_root->nodesize);
6146 check_extent_type(rec);
6147 maybe_free_extent_rec(extent_cache, rec);
6151 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6156 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6157 u64 parent, u64 root, int found_ref)
6159 struct extent_record *rec;
6160 struct tree_backref *back;
6161 struct cache_extent *cache;
6164 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6166 struct extent_record tmpl;
6168 memset(&tmpl, 0, sizeof(tmpl));
6169 tmpl.start = bytenr;
6173 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6177 /* really a bug in cache_extent implement now */
6178 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6183 rec = container_of(cache, struct extent_record, cache);
6184 if (rec->start != bytenr) {
6186 * Several cause, from unaligned bytenr to over lapping extents
6191 back = find_tree_backref(rec, parent, root);
6193 back = alloc_tree_backref(rec, parent, root);
6199 if (back->node.found_ref) {
6200 fprintf(stderr, "Extent back ref already exists "
6201 "for %llu parent %llu root %llu \n",
6202 (unsigned long long)bytenr,
6203 (unsigned long long)parent,
6204 (unsigned long long)root);
6206 back->node.found_ref = 1;
6208 if (back->node.found_extent_tree) {
6209 fprintf(stderr, "Extent back ref already exists "
6210 "for %llu parent %llu root %llu \n",
6211 (unsigned long long)bytenr,
6212 (unsigned long long)parent,
6213 (unsigned long long)root);
6215 back->node.found_extent_tree = 1;
6217 check_extent_type(rec);
6218 maybe_free_extent_rec(extent_cache, rec);
6222 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6223 u64 parent, u64 root, u64 owner, u64 offset,
6224 u32 num_refs, int found_ref, u64 max_size)
6226 struct extent_record *rec;
6227 struct data_backref *back;
6228 struct cache_extent *cache;
6231 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6233 struct extent_record tmpl;
6235 memset(&tmpl, 0, sizeof(tmpl));
6236 tmpl.start = bytenr;
6238 tmpl.max_size = max_size;
6240 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6244 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6249 rec = container_of(cache, struct extent_record, cache);
6250 if (rec->max_size < max_size)
6251 rec->max_size = max_size;
6254 * If found_ref is set then max_size is the real size and must match the
6255 * existing refs. So if we have already found a ref then we need to
6256 * make sure that this ref matches the existing one, otherwise we need
6257 * to add a new backref so we can notice that the backrefs don't match
6258 * and we need to figure out who is telling the truth. This is to
6259 * account for that awful fsync bug I introduced where we'd end up with
6260 * a btrfs_file_extent_item that would have its length include multiple
6261 * prealloc extents or point inside of a prealloc extent.
6263 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6266 back = alloc_data_backref(rec, parent, root, owner, offset,
6272 BUG_ON(num_refs != 1);
6273 if (back->node.found_ref)
6274 BUG_ON(back->bytes != max_size);
6275 back->node.found_ref = 1;
6276 back->found_ref += 1;
6277 back->bytes = max_size;
6278 back->disk_bytenr = bytenr;
6280 rec->content_checked = 1;
6281 rec->owner_ref_checked = 1;
6283 if (back->node.found_extent_tree) {
6284 fprintf(stderr, "Extent back ref already exists "
6285 "for %llu parent %llu root %llu "
6286 "owner %llu offset %llu num_refs %lu\n",
6287 (unsigned long long)bytenr,
6288 (unsigned long long)parent,
6289 (unsigned long long)root,
6290 (unsigned long long)owner,
6291 (unsigned long long)offset,
6292 (unsigned long)num_refs);
6294 back->num_refs = num_refs;
6295 back->node.found_extent_tree = 1;
6297 maybe_free_extent_rec(extent_cache, rec);
6301 static int add_pending(struct cache_tree *pending,
6302 struct cache_tree *seen, u64 bytenr, u32 size)
6305 ret = add_cache_extent(seen, bytenr, size);
6308 add_cache_extent(pending, bytenr, size);
6312 static int pick_next_pending(struct cache_tree *pending,
6313 struct cache_tree *reada,
6314 struct cache_tree *nodes,
6315 u64 last, struct block_info *bits, int bits_nr,
6318 unsigned long node_start = last;
6319 struct cache_extent *cache;
6322 cache = search_cache_extent(reada, 0);
6324 bits[0].start = cache->start;
6325 bits[0].size = cache->size;
6330 if (node_start > 32768)
6331 node_start -= 32768;
6333 cache = search_cache_extent(nodes, node_start);
6335 cache = search_cache_extent(nodes, 0);
6338 cache = search_cache_extent(pending, 0);
6343 bits[ret].start = cache->start;
6344 bits[ret].size = cache->size;
6345 cache = next_cache_extent(cache);
6347 } while (cache && ret < bits_nr);
6353 bits[ret].start = cache->start;
6354 bits[ret].size = cache->size;
6355 cache = next_cache_extent(cache);
6357 } while (cache && ret < bits_nr);
6359 if (bits_nr - ret > 8) {
6360 u64 lookup = bits[0].start + bits[0].size;
6361 struct cache_extent *next;
6362 next = search_cache_extent(pending, lookup);
6364 if (next->start - lookup > 32768)
6366 bits[ret].start = next->start;
6367 bits[ret].size = next->size;
6368 lookup = next->start + next->size;
6372 next = next_cache_extent(next);
6380 static void free_chunk_record(struct cache_extent *cache)
6382 struct chunk_record *rec;
6384 rec = container_of(cache, struct chunk_record, cache);
6385 list_del_init(&rec->list);
6386 list_del_init(&rec->dextents);
6390 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6392 cache_tree_free_extents(chunk_cache, free_chunk_record);
6395 static void free_device_record(struct rb_node *node)
6397 struct device_record *rec;
6399 rec = container_of(node, struct device_record, node);
6403 FREE_RB_BASED_TREE(device_cache, free_device_record);
6405 int insert_block_group_record(struct block_group_tree *tree,
6406 struct block_group_record *bg_rec)
6410 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6414 list_add_tail(&bg_rec->list, &tree->block_groups);
6418 static void free_block_group_record(struct cache_extent *cache)
6420 struct block_group_record *rec;
6422 rec = container_of(cache, struct block_group_record, cache);
6423 list_del_init(&rec->list);
6427 void free_block_group_tree(struct block_group_tree *tree)
6429 cache_tree_free_extents(&tree->tree, free_block_group_record);
6432 int insert_device_extent_record(struct device_extent_tree *tree,
6433 struct device_extent_record *de_rec)
6438 * Device extent is a bit different from the other extents, because
6439 * the extents which belong to the different devices may have the
6440 * same start and size, so we need use the special extent cache
6441 * search/insert functions.
6443 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6447 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6448 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6452 static void free_device_extent_record(struct cache_extent *cache)
6454 struct device_extent_record *rec;
6456 rec = container_of(cache, struct device_extent_record, cache);
6457 if (!list_empty(&rec->chunk_list))
6458 list_del_init(&rec->chunk_list);
6459 if (!list_empty(&rec->device_list))
6460 list_del_init(&rec->device_list);
6464 void free_device_extent_tree(struct device_extent_tree *tree)
6466 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6469 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6470 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6471 struct extent_buffer *leaf, int slot)
6473 struct btrfs_extent_ref_v0 *ref0;
6474 struct btrfs_key key;
6477 btrfs_item_key_to_cpu(leaf, &key, slot);
6478 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6479 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6480 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6483 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6484 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6490 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6491 struct btrfs_key *key,
6494 struct btrfs_chunk *ptr;
6495 struct chunk_record *rec;
6498 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6499 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6501 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6503 fprintf(stderr, "memory allocation failed\n");
6507 INIT_LIST_HEAD(&rec->list);
6508 INIT_LIST_HEAD(&rec->dextents);
6511 rec->cache.start = key->offset;
6512 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6514 rec->generation = btrfs_header_generation(leaf);
6516 rec->objectid = key->objectid;
6517 rec->type = key->type;
6518 rec->offset = key->offset;
6520 rec->length = rec->cache.size;
6521 rec->owner = btrfs_chunk_owner(leaf, ptr);
6522 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6523 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6524 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6525 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6526 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6527 rec->num_stripes = num_stripes;
6528 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6530 for (i = 0; i < rec->num_stripes; ++i) {
6531 rec->stripes[i].devid =
6532 btrfs_stripe_devid_nr(leaf, ptr, i);
6533 rec->stripes[i].offset =
6534 btrfs_stripe_offset_nr(leaf, ptr, i);
6535 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6536 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6543 static int process_chunk_item(struct cache_tree *chunk_cache,
6544 struct btrfs_key *key, struct extent_buffer *eb,
6547 struct chunk_record *rec;
6548 struct btrfs_chunk *chunk;
6551 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6553 * Do extra check for this chunk item,
6555 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6556 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6557 * and owner<->key_type check.
6559 ret = btrfs_check_chunk_valid(global_info->tree_root, eb, chunk, slot,
6562 error("chunk(%llu, %llu) is not valid, ignore it",
6563 key->offset, btrfs_chunk_length(eb, chunk));
6566 rec = btrfs_new_chunk_record(eb, key, slot);
6567 ret = insert_cache_extent(chunk_cache, &rec->cache);
6569 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6570 rec->offset, rec->length);
6577 static int process_device_item(struct rb_root *dev_cache,
6578 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6580 struct btrfs_dev_item *ptr;
6581 struct device_record *rec;
6584 ptr = btrfs_item_ptr(eb,
6585 slot, struct btrfs_dev_item);
6587 rec = malloc(sizeof(*rec));
6589 fprintf(stderr, "memory allocation failed\n");
6593 rec->devid = key->offset;
6594 rec->generation = btrfs_header_generation(eb);
6596 rec->objectid = key->objectid;
6597 rec->type = key->type;
6598 rec->offset = key->offset;
6600 rec->devid = btrfs_device_id(eb, ptr);
6601 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6602 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6604 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6606 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6613 struct block_group_record *
6614 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6617 struct btrfs_block_group_item *ptr;
6618 struct block_group_record *rec;
6620 rec = calloc(1, sizeof(*rec));
6622 fprintf(stderr, "memory allocation failed\n");
6626 rec->cache.start = key->objectid;
6627 rec->cache.size = key->offset;
6629 rec->generation = btrfs_header_generation(leaf);
6631 rec->objectid = key->objectid;
6632 rec->type = key->type;
6633 rec->offset = key->offset;
6635 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6636 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6638 INIT_LIST_HEAD(&rec->list);
6643 static int process_block_group_item(struct block_group_tree *block_group_cache,
6644 struct btrfs_key *key,
6645 struct extent_buffer *eb, int slot)
6647 struct block_group_record *rec;
6650 rec = btrfs_new_block_group_record(eb, key, slot);
6651 ret = insert_block_group_record(block_group_cache, rec);
6653 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6654 rec->objectid, rec->offset);
6661 struct device_extent_record *
6662 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6663 struct btrfs_key *key, int slot)
6665 struct device_extent_record *rec;
6666 struct btrfs_dev_extent *ptr;
6668 rec = calloc(1, sizeof(*rec));
6670 fprintf(stderr, "memory allocation failed\n");
6674 rec->cache.objectid = key->objectid;
6675 rec->cache.start = key->offset;
6677 rec->generation = btrfs_header_generation(leaf);
6679 rec->objectid = key->objectid;
6680 rec->type = key->type;
6681 rec->offset = key->offset;
6683 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6684 rec->chunk_objecteid =
6685 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6687 btrfs_dev_extent_chunk_offset(leaf, ptr);
6688 rec->length = btrfs_dev_extent_length(leaf, ptr);
6689 rec->cache.size = rec->length;
6691 INIT_LIST_HEAD(&rec->chunk_list);
6692 INIT_LIST_HEAD(&rec->device_list);
6698 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6699 struct btrfs_key *key, struct extent_buffer *eb,
6702 struct device_extent_record *rec;
6705 rec = btrfs_new_device_extent_record(eb, key, slot);
6706 ret = insert_device_extent_record(dev_extent_cache, rec);
6709 "Device extent[%llu, %llu, %llu] existed.\n",
6710 rec->objectid, rec->offset, rec->length);
6717 static int process_extent_item(struct btrfs_root *root,
6718 struct cache_tree *extent_cache,
6719 struct extent_buffer *eb, int slot)
6721 struct btrfs_extent_item *ei;
6722 struct btrfs_extent_inline_ref *iref;
6723 struct btrfs_extent_data_ref *dref;
6724 struct btrfs_shared_data_ref *sref;
6725 struct btrfs_key key;
6726 struct extent_record tmpl;
6731 u32 item_size = btrfs_item_size_nr(eb, slot);
6737 btrfs_item_key_to_cpu(eb, &key, slot);
6739 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6741 num_bytes = root->nodesize;
6743 num_bytes = key.offset;
6746 if (!IS_ALIGNED(key.objectid, root->sectorsize)) {
6747 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6748 key.objectid, root->sectorsize);
6751 if (item_size < sizeof(*ei)) {
6752 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6753 struct btrfs_extent_item_v0 *ei0;
6754 BUG_ON(item_size != sizeof(*ei0));
6755 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6756 refs = btrfs_extent_refs_v0(eb, ei0);
6760 memset(&tmpl, 0, sizeof(tmpl));
6761 tmpl.start = key.objectid;
6762 tmpl.nr = num_bytes;
6763 tmpl.extent_item_refs = refs;
6764 tmpl.metadata = metadata;
6766 tmpl.max_size = num_bytes;
6768 return add_extent_rec(extent_cache, &tmpl);
6771 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6772 refs = btrfs_extent_refs(eb, ei);
6773 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6777 if (metadata && num_bytes != root->nodesize) {
6778 error("ignore invalid metadata extent, length %llu does not equal to %u",
6779 num_bytes, root->nodesize);
6782 if (!metadata && !IS_ALIGNED(num_bytes, root->sectorsize)) {
6783 error("ignore invalid data extent, length %llu is not aligned to %u",
6784 num_bytes, root->sectorsize);
6788 memset(&tmpl, 0, sizeof(tmpl));
6789 tmpl.start = key.objectid;
6790 tmpl.nr = num_bytes;
6791 tmpl.extent_item_refs = refs;
6792 tmpl.metadata = metadata;
6794 tmpl.max_size = num_bytes;
6795 add_extent_rec(extent_cache, &tmpl);
6797 ptr = (unsigned long)(ei + 1);
6798 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6799 key.type == BTRFS_EXTENT_ITEM_KEY)
6800 ptr += sizeof(struct btrfs_tree_block_info);
6802 end = (unsigned long)ei + item_size;
6804 iref = (struct btrfs_extent_inline_ref *)ptr;
6805 type = btrfs_extent_inline_ref_type(eb, iref);
6806 offset = btrfs_extent_inline_ref_offset(eb, iref);
6808 case BTRFS_TREE_BLOCK_REF_KEY:
6809 ret = add_tree_backref(extent_cache, key.objectid,
6812 error("add_tree_backref failed: %s",
6815 case BTRFS_SHARED_BLOCK_REF_KEY:
6816 ret = add_tree_backref(extent_cache, key.objectid,
6819 error("add_tree_backref failed: %s",
6822 case BTRFS_EXTENT_DATA_REF_KEY:
6823 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6824 add_data_backref(extent_cache, key.objectid, 0,
6825 btrfs_extent_data_ref_root(eb, dref),
6826 btrfs_extent_data_ref_objectid(eb,
6828 btrfs_extent_data_ref_offset(eb, dref),
6829 btrfs_extent_data_ref_count(eb, dref),
6832 case BTRFS_SHARED_DATA_REF_KEY:
6833 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6834 add_data_backref(extent_cache, key.objectid, offset,
6836 btrfs_shared_data_ref_count(eb, sref),
6840 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6841 key.objectid, key.type, num_bytes);
6844 ptr += btrfs_extent_inline_ref_size(type);
6851 static int check_cache_range(struct btrfs_root *root,
6852 struct btrfs_block_group_cache *cache,
6853 u64 offset, u64 bytes)
6855 struct btrfs_free_space *entry;
6861 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6862 bytenr = btrfs_sb_offset(i);
6863 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
6864 cache->key.objectid, bytenr, 0,
6865 &logical, &nr, &stripe_len);
6870 if (logical[nr] + stripe_len <= offset)
6872 if (offset + bytes <= logical[nr])
6874 if (logical[nr] == offset) {
6875 if (stripe_len >= bytes) {
6879 bytes -= stripe_len;
6880 offset += stripe_len;
6881 } else if (logical[nr] < offset) {
6882 if (logical[nr] + stripe_len >=
6887 bytes = (offset + bytes) -
6888 (logical[nr] + stripe_len);
6889 offset = logical[nr] + stripe_len;
6892 * Could be tricky, the super may land in the
6893 * middle of the area we're checking. First
6894 * check the easiest case, it's at the end.
6896 if (logical[nr] + stripe_len >=
6898 bytes = logical[nr] - offset;
6902 /* Check the left side */
6903 ret = check_cache_range(root, cache,
6905 logical[nr] - offset);
6911 /* Now we continue with the right side */
6912 bytes = (offset + bytes) -
6913 (logical[nr] + stripe_len);
6914 offset = logical[nr] + stripe_len;
6921 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
6923 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
6924 offset, offset+bytes);
6928 if (entry->offset != offset) {
6929 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
6934 if (entry->bytes != bytes) {
6935 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
6936 bytes, entry->bytes, offset);
6940 unlink_free_space(cache->free_space_ctl, entry);
6945 static int verify_space_cache(struct btrfs_root *root,
6946 struct btrfs_block_group_cache *cache)
6948 struct btrfs_path path;
6949 struct extent_buffer *leaf;
6950 struct btrfs_key key;
6954 root = root->fs_info->extent_root;
6956 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
6958 btrfs_init_path(&path);
6959 key.objectid = last;
6961 key.type = BTRFS_EXTENT_ITEM_KEY;
6962 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6967 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
6968 ret = btrfs_next_leaf(root, &path);
6976 leaf = path.nodes[0];
6977 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
6978 if (key.objectid >= cache->key.offset + cache->key.objectid)
6980 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
6981 key.type != BTRFS_METADATA_ITEM_KEY) {
6986 if (last == key.objectid) {
6987 if (key.type == BTRFS_EXTENT_ITEM_KEY)
6988 last = key.objectid + key.offset;
6990 last = key.objectid + root->nodesize;
6995 ret = check_cache_range(root, cache, last,
6996 key.objectid - last);
6999 if (key.type == BTRFS_EXTENT_ITEM_KEY)
7000 last = key.objectid + key.offset;
7002 last = key.objectid + root->nodesize;
7006 if (last < cache->key.objectid + cache->key.offset)
7007 ret = check_cache_range(root, cache, last,
7008 cache->key.objectid +
7009 cache->key.offset - last);
7012 btrfs_release_path(&path);
7015 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
7016 fprintf(stderr, "There are still entries left in the space "
7024 static int check_space_cache(struct btrfs_root *root)
7026 struct btrfs_block_group_cache *cache;
7027 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7031 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7032 btrfs_super_generation(root->fs_info->super_copy) !=
7033 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7034 printf("cache and super generation don't match, space cache "
7035 "will be invalidated\n");
7039 if (ctx.progress_enabled) {
7040 ctx.tp = TASK_FREE_SPACE;
7041 task_start(ctx.info);
7045 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7049 start = cache->key.objectid + cache->key.offset;
7050 if (!cache->free_space_ctl) {
7051 if (btrfs_init_free_space_ctl(cache,
7052 root->sectorsize)) {
7057 btrfs_remove_free_space_cache(cache);
7060 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7061 ret = exclude_super_stripes(root, cache);
7063 fprintf(stderr, "could not exclude super stripes: %s\n",
7068 ret = load_free_space_tree(root->fs_info, cache);
7069 free_excluded_extents(root, cache);
7071 fprintf(stderr, "could not load free space tree: %s\n",
7078 ret = load_free_space_cache(root->fs_info, cache);
7083 ret = verify_space_cache(root, cache);
7085 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7086 cache->key.objectid);
7091 task_stop(ctx.info);
7093 return error ? -EINVAL : 0;
7096 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7097 u64 num_bytes, unsigned long leaf_offset,
7098 struct extent_buffer *eb) {
7101 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7103 unsigned long csum_offset;
7107 u64 data_checked = 0;
7113 if (num_bytes % root->sectorsize)
7116 data = malloc(num_bytes);
7120 while (offset < num_bytes) {
7123 read_len = num_bytes - offset;
7124 /* read as much space once a time */
7125 ret = read_extent_data(root, data + offset,
7126 bytenr + offset, &read_len, mirror);
7130 /* verify every 4k data's checksum */
7131 while (data_checked < read_len) {
7133 tmp = offset + data_checked;
7135 csum = btrfs_csum_data((char *)data + tmp,
7136 csum, root->sectorsize);
7137 btrfs_csum_final(csum, (u8 *)&csum);
7139 csum_offset = leaf_offset +
7140 tmp / root->sectorsize * csum_size;
7141 read_extent_buffer(eb, (char *)&csum_expected,
7142 csum_offset, csum_size);
7143 /* try another mirror */
7144 if (csum != csum_expected) {
7145 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7146 mirror, bytenr + tmp,
7147 csum, csum_expected);
7148 num_copies = btrfs_num_copies(
7149 &root->fs_info->mapping_tree,
7151 if (mirror < num_copies - 1) {
7156 data_checked += root->sectorsize;
7165 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7168 struct btrfs_path path;
7169 struct extent_buffer *leaf;
7170 struct btrfs_key key;
7173 btrfs_init_path(&path);
7174 key.objectid = bytenr;
7175 key.type = BTRFS_EXTENT_ITEM_KEY;
7176 key.offset = (u64)-1;
7179 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7182 fprintf(stderr, "Error looking up extent record %d\n", ret);
7183 btrfs_release_path(&path);
7186 if (path.slots[0] > 0) {
7189 ret = btrfs_prev_leaf(root, &path);
7192 } else if (ret > 0) {
7199 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7202 * Block group items come before extent items if they have the same
7203 * bytenr, so walk back one more just in case. Dear future traveller,
7204 * first congrats on mastering time travel. Now if it's not too much
7205 * trouble could you go back to 2006 and tell Chris to make the
7206 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7207 * EXTENT_ITEM_KEY please?
7209 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7210 if (path.slots[0] > 0) {
7213 ret = btrfs_prev_leaf(root, &path);
7216 } else if (ret > 0) {
7221 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7225 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7226 ret = btrfs_next_leaf(root, &path);
7228 fprintf(stderr, "Error going to next leaf "
7230 btrfs_release_path(&path);
7236 leaf = path.nodes[0];
7237 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7238 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7242 if (key.objectid + key.offset < bytenr) {
7246 if (key.objectid > bytenr + num_bytes)
7249 if (key.objectid == bytenr) {
7250 if (key.offset >= num_bytes) {
7254 num_bytes -= key.offset;
7255 bytenr += key.offset;
7256 } else if (key.objectid < bytenr) {
7257 if (key.objectid + key.offset >= bytenr + num_bytes) {
7261 num_bytes = (bytenr + num_bytes) -
7262 (key.objectid + key.offset);
7263 bytenr = key.objectid + key.offset;
7265 if (key.objectid + key.offset < bytenr + num_bytes) {
7266 u64 new_start = key.objectid + key.offset;
7267 u64 new_bytes = bytenr + num_bytes - new_start;
7270 * Weird case, the extent is in the middle of
7271 * our range, we'll have to search one side
7272 * and then the other. Not sure if this happens
7273 * in real life, but no harm in coding it up
7274 * anyway just in case.
7276 btrfs_release_path(&path);
7277 ret = check_extent_exists(root, new_start,
7280 fprintf(stderr, "Right section didn't "
7284 num_bytes = key.objectid - bytenr;
7287 num_bytes = key.objectid - bytenr;
7294 if (num_bytes && !ret) {
7295 fprintf(stderr, "There are no extents for csum range "
7296 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7300 btrfs_release_path(&path);
7304 static int check_csums(struct btrfs_root *root)
7306 struct btrfs_path path;
7307 struct extent_buffer *leaf;
7308 struct btrfs_key key;
7309 u64 offset = 0, num_bytes = 0;
7310 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7314 unsigned long leaf_offset;
7316 root = root->fs_info->csum_root;
7317 if (!extent_buffer_uptodate(root->node)) {
7318 fprintf(stderr, "No valid csum tree found\n");
7322 btrfs_init_path(&path);
7323 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7324 key.type = BTRFS_EXTENT_CSUM_KEY;
7326 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7328 fprintf(stderr, "Error searching csum tree %d\n", ret);
7329 btrfs_release_path(&path);
7333 if (ret > 0 && path.slots[0])
7338 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7339 ret = btrfs_next_leaf(root, &path);
7341 fprintf(stderr, "Error going to next leaf "
7348 leaf = path.nodes[0];
7350 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7351 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7356 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7357 csum_size) * root->sectorsize;
7358 if (!check_data_csum)
7359 goto skip_csum_check;
7360 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7361 ret = check_extent_csums(root, key.offset, data_len,
7367 offset = key.offset;
7368 } else if (key.offset != offset + num_bytes) {
7369 ret = check_extent_exists(root, offset, num_bytes);
7371 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7372 "there is no extent record\n",
7373 offset, offset+num_bytes);
7376 offset = key.offset;
7379 num_bytes += data_len;
7383 btrfs_release_path(&path);
7387 static int is_dropped_key(struct btrfs_key *key,
7388 struct btrfs_key *drop_key) {
7389 if (key->objectid < drop_key->objectid)
7391 else if (key->objectid == drop_key->objectid) {
7392 if (key->type < drop_key->type)
7394 else if (key->type == drop_key->type) {
7395 if (key->offset < drop_key->offset)
7403 * Here are the rules for FULL_BACKREF.
7405 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7406 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7408 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7409 * if it happened after the relocation occurred since we'll have dropped the
7410 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7411 * have no real way to know for sure.
7413 * We process the blocks one root at a time, and we start from the lowest root
7414 * objectid and go to the highest. So we can just lookup the owner backref for
7415 * the record and if we don't find it then we know it doesn't exist and we have
7418 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7419 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7420 * be set or not and then we can check later once we've gathered all the refs.
7422 static int calc_extent_flag(struct cache_tree *extent_cache,
7423 struct extent_buffer *buf,
7424 struct root_item_record *ri,
7427 struct extent_record *rec;
7428 struct cache_extent *cache;
7429 struct tree_backref *tback;
7432 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7433 /* we have added this extent before */
7437 rec = container_of(cache, struct extent_record, cache);
7440 * Except file/reloc tree, we can not have
7443 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7448 if (buf->start == ri->bytenr)
7451 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7454 owner = btrfs_header_owner(buf);
7455 if (owner == ri->objectid)
7458 tback = find_tree_backref(rec, 0, owner);
7463 if (rec->flag_block_full_backref != FLAG_UNSET &&
7464 rec->flag_block_full_backref != 0)
7465 rec->bad_full_backref = 1;
7468 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7469 if (rec->flag_block_full_backref != FLAG_UNSET &&
7470 rec->flag_block_full_backref != 1)
7471 rec->bad_full_backref = 1;
7475 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7477 fprintf(stderr, "Invalid key type(");
7478 print_key_type(stderr, 0, key_type);
7479 fprintf(stderr, ") found in root(");
7480 print_objectid(stderr, rootid, 0);
7481 fprintf(stderr, ")\n");
7485 * Check if the key is valid with its extent buffer.
7487 * This is a early check in case invalid key exists in a extent buffer
7488 * This is not comprehensive yet, but should prevent wrong key/item passed
7491 static int check_type_with_root(u64 rootid, u8 key_type)
7494 /* Only valid in chunk tree */
7495 case BTRFS_DEV_ITEM_KEY:
7496 case BTRFS_CHUNK_ITEM_KEY:
7497 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7500 /* valid in csum and log tree */
7501 case BTRFS_CSUM_TREE_OBJECTID:
7502 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7506 case BTRFS_EXTENT_ITEM_KEY:
7507 case BTRFS_METADATA_ITEM_KEY:
7508 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7509 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7512 case BTRFS_ROOT_ITEM_KEY:
7513 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7516 case BTRFS_DEV_EXTENT_KEY:
7517 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7523 report_mismatch_key_root(key_type, rootid);
7527 static int run_next_block(struct btrfs_root *root,
7528 struct block_info *bits,
7531 struct cache_tree *pending,
7532 struct cache_tree *seen,
7533 struct cache_tree *reada,
7534 struct cache_tree *nodes,
7535 struct cache_tree *extent_cache,
7536 struct cache_tree *chunk_cache,
7537 struct rb_root *dev_cache,
7538 struct block_group_tree *block_group_cache,
7539 struct device_extent_tree *dev_extent_cache,
7540 struct root_item_record *ri)
7542 struct extent_buffer *buf;
7543 struct extent_record *rec = NULL;
7554 struct btrfs_key key;
7555 struct cache_extent *cache;
7558 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7559 bits_nr, &reada_bits);
7564 for(i = 0; i < nritems; i++) {
7565 ret = add_cache_extent(reada, bits[i].start,
7570 /* fixme, get the parent transid */
7571 readahead_tree_block(root, bits[i].start,
7575 *last = bits[0].start;
7576 bytenr = bits[0].start;
7577 size = bits[0].size;
7579 cache = lookup_cache_extent(pending, bytenr, size);
7581 remove_cache_extent(pending, cache);
7584 cache = lookup_cache_extent(reada, bytenr, size);
7586 remove_cache_extent(reada, cache);
7589 cache = lookup_cache_extent(nodes, bytenr, size);
7591 remove_cache_extent(nodes, cache);
7594 cache = lookup_cache_extent(extent_cache, bytenr, size);
7596 rec = container_of(cache, struct extent_record, cache);
7597 gen = rec->parent_generation;
7600 /* fixme, get the real parent transid */
7601 buf = read_tree_block(root, bytenr, size, gen);
7602 if (!extent_buffer_uptodate(buf)) {
7603 record_bad_block_io(root->fs_info,
7604 extent_cache, bytenr, size);
7608 nritems = btrfs_header_nritems(buf);
7611 if (!init_extent_tree) {
7612 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7613 btrfs_header_level(buf), 1, NULL,
7616 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7618 fprintf(stderr, "Couldn't calc extent flags\n");
7619 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7624 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7626 fprintf(stderr, "Couldn't calc extent flags\n");
7627 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7631 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7633 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7634 ri->objectid == btrfs_header_owner(buf)) {
7636 * Ok we got to this block from it's original owner and
7637 * we have FULL_BACKREF set. Relocation can leave
7638 * converted blocks over so this is altogether possible,
7639 * however it's not possible if the generation > the
7640 * last snapshot, so check for this case.
7642 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7643 btrfs_header_generation(buf) > ri->last_snapshot) {
7644 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7645 rec->bad_full_backref = 1;
7650 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7651 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7652 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7653 rec->bad_full_backref = 1;
7657 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7658 rec->flag_block_full_backref = 1;
7662 rec->flag_block_full_backref = 0;
7664 owner = btrfs_header_owner(buf);
7667 ret = check_block(root, extent_cache, buf, flags);
7671 if (btrfs_is_leaf(buf)) {
7672 btree_space_waste += btrfs_leaf_free_space(root, buf);
7673 for (i = 0; i < nritems; i++) {
7674 struct btrfs_file_extent_item *fi;
7675 btrfs_item_key_to_cpu(buf, &key, i);
7677 * Check key type against the leaf owner.
7678 * Could filter quite a lot of early error if
7681 if (check_type_with_root(btrfs_header_owner(buf),
7683 fprintf(stderr, "ignoring invalid key\n");
7686 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7687 process_extent_item(root, extent_cache, buf,
7691 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7692 process_extent_item(root, extent_cache, buf,
7696 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7698 btrfs_item_size_nr(buf, i);
7701 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7702 process_chunk_item(chunk_cache, &key, buf, i);
7705 if (key.type == BTRFS_DEV_ITEM_KEY) {
7706 process_device_item(dev_cache, &key, buf, i);
7709 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7710 process_block_group_item(block_group_cache,
7714 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7715 process_device_extent_item(dev_extent_cache,
7720 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7721 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7722 process_extent_ref_v0(extent_cache, buf, i);
7729 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7730 ret = add_tree_backref(extent_cache,
7731 key.objectid, 0, key.offset, 0);
7733 error("add_tree_backref failed: %s",
7737 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7738 ret = add_tree_backref(extent_cache,
7739 key.objectid, key.offset, 0, 0);
7741 error("add_tree_backref failed: %s",
7745 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7746 struct btrfs_extent_data_ref *ref;
7747 ref = btrfs_item_ptr(buf, i,
7748 struct btrfs_extent_data_ref);
7749 add_data_backref(extent_cache,
7751 btrfs_extent_data_ref_root(buf, ref),
7752 btrfs_extent_data_ref_objectid(buf,
7754 btrfs_extent_data_ref_offset(buf, ref),
7755 btrfs_extent_data_ref_count(buf, ref),
7756 0, root->sectorsize);
7759 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7760 struct btrfs_shared_data_ref *ref;
7761 ref = btrfs_item_ptr(buf, i,
7762 struct btrfs_shared_data_ref);
7763 add_data_backref(extent_cache,
7764 key.objectid, key.offset, 0, 0, 0,
7765 btrfs_shared_data_ref_count(buf, ref),
7766 0, root->sectorsize);
7769 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7770 struct bad_item *bad;
7772 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7776 bad = malloc(sizeof(struct bad_item));
7779 INIT_LIST_HEAD(&bad->list);
7780 memcpy(&bad->key, &key,
7781 sizeof(struct btrfs_key));
7782 bad->root_id = owner;
7783 list_add_tail(&bad->list, &delete_items);
7786 if (key.type != BTRFS_EXTENT_DATA_KEY)
7788 fi = btrfs_item_ptr(buf, i,
7789 struct btrfs_file_extent_item);
7790 if (btrfs_file_extent_type(buf, fi) ==
7791 BTRFS_FILE_EXTENT_INLINE)
7793 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7796 data_bytes_allocated +=
7797 btrfs_file_extent_disk_num_bytes(buf, fi);
7798 if (data_bytes_allocated < root->sectorsize) {
7801 data_bytes_referenced +=
7802 btrfs_file_extent_num_bytes(buf, fi);
7803 add_data_backref(extent_cache,
7804 btrfs_file_extent_disk_bytenr(buf, fi),
7805 parent, owner, key.objectid, key.offset -
7806 btrfs_file_extent_offset(buf, fi), 1, 1,
7807 btrfs_file_extent_disk_num_bytes(buf, fi));
7811 struct btrfs_key first_key;
7813 first_key.objectid = 0;
7816 btrfs_item_key_to_cpu(buf, &first_key, 0);
7817 level = btrfs_header_level(buf);
7818 for (i = 0; i < nritems; i++) {
7819 struct extent_record tmpl;
7821 ptr = btrfs_node_blockptr(buf, i);
7822 size = root->nodesize;
7823 btrfs_node_key_to_cpu(buf, &key, i);
7825 if ((level == ri->drop_level)
7826 && is_dropped_key(&key, &ri->drop_key)) {
7831 memset(&tmpl, 0, sizeof(tmpl));
7832 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7833 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7838 tmpl.max_size = size;
7839 ret = add_extent_rec(extent_cache, &tmpl);
7843 ret = add_tree_backref(extent_cache, ptr, parent,
7846 error("add_tree_backref failed: %s",
7852 add_pending(nodes, seen, ptr, size);
7854 add_pending(pending, seen, ptr, size);
7857 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7858 nritems) * sizeof(struct btrfs_key_ptr);
7860 total_btree_bytes += buf->len;
7861 if (fs_root_objectid(btrfs_header_owner(buf)))
7862 total_fs_tree_bytes += buf->len;
7863 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7864 total_extent_tree_bytes += buf->len;
7865 if (!found_old_backref &&
7866 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7867 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7868 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7869 found_old_backref = 1;
7871 free_extent_buffer(buf);
7875 static int add_root_to_pending(struct extent_buffer *buf,
7876 struct cache_tree *extent_cache,
7877 struct cache_tree *pending,
7878 struct cache_tree *seen,
7879 struct cache_tree *nodes,
7882 struct extent_record tmpl;
7885 if (btrfs_header_level(buf) > 0)
7886 add_pending(nodes, seen, buf->start, buf->len);
7888 add_pending(pending, seen, buf->start, buf->len);
7890 memset(&tmpl, 0, sizeof(tmpl));
7891 tmpl.start = buf->start;
7896 tmpl.max_size = buf->len;
7897 add_extent_rec(extent_cache, &tmpl);
7899 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7900 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7901 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7904 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7909 /* as we fix the tree, we might be deleting blocks that
7910 * we're tracking for repair. This hook makes sure we
7911 * remove any backrefs for blocks as we are fixing them.
7913 static int free_extent_hook(struct btrfs_trans_handle *trans,
7914 struct btrfs_root *root,
7915 u64 bytenr, u64 num_bytes, u64 parent,
7916 u64 root_objectid, u64 owner, u64 offset,
7919 struct extent_record *rec;
7920 struct cache_extent *cache;
7922 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
7924 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
7925 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
7929 rec = container_of(cache, struct extent_record, cache);
7931 struct data_backref *back;
7932 back = find_data_backref(rec, parent, root_objectid, owner,
7933 offset, 1, bytenr, num_bytes);
7936 if (back->node.found_ref) {
7937 back->found_ref -= refs_to_drop;
7939 rec->refs -= refs_to_drop;
7941 if (back->node.found_extent_tree) {
7942 back->num_refs -= refs_to_drop;
7943 if (rec->extent_item_refs)
7944 rec->extent_item_refs -= refs_to_drop;
7946 if (back->found_ref == 0)
7947 back->node.found_ref = 0;
7948 if (back->num_refs == 0)
7949 back->node.found_extent_tree = 0;
7951 if (!back->node.found_extent_tree && back->node.found_ref) {
7952 list_del(&back->node.list);
7956 struct tree_backref *back;
7957 back = find_tree_backref(rec, parent, root_objectid);
7960 if (back->node.found_ref) {
7963 back->node.found_ref = 0;
7965 if (back->node.found_extent_tree) {
7966 if (rec->extent_item_refs)
7967 rec->extent_item_refs--;
7968 back->node.found_extent_tree = 0;
7970 if (!back->node.found_extent_tree && back->node.found_ref) {
7971 list_del(&back->node.list);
7975 maybe_free_extent_rec(extent_cache, rec);
7980 static int delete_extent_records(struct btrfs_trans_handle *trans,
7981 struct btrfs_root *root,
7982 struct btrfs_path *path,
7985 struct btrfs_key key;
7986 struct btrfs_key found_key;
7987 struct extent_buffer *leaf;
7992 key.objectid = bytenr;
7994 key.offset = (u64)-1;
7997 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
8004 if (path->slots[0] == 0)
8010 leaf = path->nodes[0];
8011 slot = path->slots[0];
8013 btrfs_item_key_to_cpu(leaf, &found_key, slot);
8014 if (found_key.objectid != bytenr)
8017 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
8018 found_key.type != BTRFS_METADATA_ITEM_KEY &&
8019 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
8020 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
8021 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
8022 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
8023 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
8024 btrfs_release_path(path);
8025 if (found_key.type == 0) {
8026 if (found_key.offset == 0)
8028 key.offset = found_key.offset - 1;
8029 key.type = found_key.type;
8031 key.type = found_key.type - 1;
8032 key.offset = (u64)-1;
8036 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8037 found_key.objectid, found_key.type, found_key.offset);
8039 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8042 btrfs_release_path(path);
8044 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8045 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8046 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8047 found_key.offset : root->nodesize;
8049 ret = btrfs_update_block_group(trans, root, bytenr,
8056 btrfs_release_path(path);
8061 * for a single backref, this will allocate a new extent
8062 * and add the backref to it.
8064 static int record_extent(struct btrfs_trans_handle *trans,
8065 struct btrfs_fs_info *info,
8066 struct btrfs_path *path,
8067 struct extent_record *rec,
8068 struct extent_backref *back,
8069 int allocated, u64 flags)
8072 struct btrfs_root *extent_root = info->extent_root;
8073 struct extent_buffer *leaf;
8074 struct btrfs_key ins_key;
8075 struct btrfs_extent_item *ei;
8076 struct data_backref *dback;
8077 struct btrfs_tree_block_info *bi;
8080 rec->max_size = max_t(u64, rec->max_size,
8081 info->extent_root->nodesize);
8084 u32 item_size = sizeof(*ei);
8087 item_size += sizeof(*bi);
8089 ins_key.objectid = rec->start;
8090 ins_key.offset = rec->max_size;
8091 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8093 ret = btrfs_insert_empty_item(trans, extent_root, path,
8094 &ins_key, item_size);
8098 leaf = path->nodes[0];
8099 ei = btrfs_item_ptr(leaf, path->slots[0],
8100 struct btrfs_extent_item);
8102 btrfs_set_extent_refs(leaf, ei, 0);
8103 btrfs_set_extent_generation(leaf, ei, rec->generation);
8105 if (back->is_data) {
8106 btrfs_set_extent_flags(leaf, ei,
8107 BTRFS_EXTENT_FLAG_DATA);
8109 struct btrfs_disk_key copy_key;;
8111 bi = (struct btrfs_tree_block_info *)(ei + 1);
8112 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8115 btrfs_set_disk_key_objectid(©_key,
8116 rec->info_objectid);
8117 btrfs_set_disk_key_type(©_key, 0);
8118 btrfs_set_disk_key_offset(©_key, 0);
8120 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8121 btrfs_set_tree_block_key(leaf, bi, ©_key);
8123 btrfs_set_extent_flags(leaf, ei,
8124 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8127 btrfs_mark_buffer_dirty(leaf);
8128 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8129 rec->max_size, 1, 0);
8132 btrfs_release_path(path);
8135 if (back->is_data) {
8139 dback = to_data_backref(back);
8140 if (back->full_backref)
8141 parent = dback->parent;
8145 for (i = 0; i < dback->found_ref; i++) {
8146 /* if parent != 0, we're doing a full backref
8147 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8148 * just makes the backref allocator create a data
8151 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8152 rec->start, rec->max_size,
8156 BTRFS_FIRST_FREE_OBJECTID :
8162 fprintf(stderr, "adding new data backref"
8163 " on %llu %s %llu owner %llu"
8164 " offset %llu found %d\n",
8165 (unsigned long long)rec->start,
8166 back->full_backref ?
8168 back->full_backref ?
8169 (unsigned long long)parent :
8170 (unsigned long long)dback->root,
8171 (unsigned long long)dback->owner,
8172 (unsigned long long)dback->offset,
8176 struct tree_backref *tback;
8178 tback = to_tree_backref(back);
8179 if (back->full_backref)
8180 parent = tback->parent;
8184 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8185 rec->start, rec->max_size,
8186 parent, tback->root, 0, 0);
8187 fprintf(stderr, "adding new tree backref on "
8188 "start %llu len %llu parent %llu root %llu\n",
8189 rec->start, rec->max_size, parent, tback->root);
8192 btrfs_release_path(path);
8196 static struct extent_entry *find_entry(struct list_head *entries,
8197 u64 bytenr, u64 bytes)
8199 struct extent_entry *entry = NULL;
8201 list_for_each_entry(entry, entries, list) {
8202 if (entry->bytenr == bytenr && entry->bytes == bytes)
8209 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8211 struct extent_entry *entry, *best = NULL, *prev = NULL;
8213 list_for_each_entry(entry, entries, list) {
8215 * If there are as many broken entries as entries then we know
8216 * not to trust this particular entry.
8218 if (entry->broken == entry->count)
8222 * Special case, when there are only two entries and 'best' is
8232 * If our current entry == best then we can't be sure our best
8233 * is really the best, so we need to keep searching.
8235 if (best && best->count == entry->count) {
8241 /* Prev == entry, not good enough, have to keep searching */
8242 if (!prev->broken && prev->count == entry->count)
8246 best = (prev->count > entry->count) ? prev : entry;
8247 else if (best->count < entry->count)
8255 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8256 struct data_backref *dback, struct extent_entry *entry)
8258 struct btrfs_trans_handle *trans;
8259 struct btrfs_root *root;
8260 struct btrfs_file_extent_item *fi;
8261 struct extent_buffer *leaf;
8262 struct btrfs_key key;
8266 key.objectid = dback->root;
8267 key.type = BTRFS_ROOT_ITEM_KEY;
8268 key.offset = (u64)-1;
8269 root = btrfs_read_fs_root(info, &key);
8271 fprintf(stderr, "Couldn't find root for our ref\n");
8276 * The backref points to the original offset of the extent if it was
8277 * split, so we need to search down to the offset we have and then walk
8278 * forward until we find the backref we're looking for.
8280 key.objectid = dback->owner;
8281 key.type = BTRFS_EXTENT_DATA_KEY;
8282 key.offset = dback->offset;
8283 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8285 fprintf(stderr, "Error looking up ref %d\n", ret);
8290 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8291 ret = btrfs_next_leaf(root, path);
8293 fprintf(stderr, "Couldn't find our ref, next\n");
8297 leaf = path->nodes[0];
8298 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8299 if (key.objectid != dback->owner ||
8300 key.type != BTRFS_EXTENT_DATA_KEY) {
8301 fprintf(stderr, "Couldn't find our ref, search\n");
8304 fi = btrfs_item_ptr(leaf, path->slots[0],
8305 struct btrfs_file_extent_item);
8306 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8307 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8309 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8314 btrfs_release_path(path);
8316 trans = btrfs_start_transaction(root, 1);
8318 return PTR_ERR(trans);
8321 * Ok we have the key of the file extent we want to fix, now we can cow
8322 * down to the thing and fix it.
8324 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8326 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8327 key.objectid, key.type, key.offset, ret);
8331 fprintf(stderr, "Well that's odd, we just found this key "
8332 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8337 leaf = path->nodes[0];
8338 fi = btrfs_item_ptr(leaf, path->slots[0],
8339 struct btrfs_file_extent_item);
8341 if (btrfs_file_extent_compression(leaf, fi) &&
8342 dback->disk_bytenr != entry->bytenr) {
8343 fprintf(stderr, "Ref doesn't match the record start and is "
8344 "compressed, please take a btrfs-image of this file "
8345 "system and send it to a btrfs developer so they can "
8346 "complete this functionality for bytenr %Lu\n",
8347 dback->disk_bytenr);
8352 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8353 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8354 } else if (dback->disk_bytenr > entry->bytenr) {
8355 u64 off_diff, offset;
8357 off_diff = dback->disk_bytenr - entry->bytenr;
8358 offset = btrfs_file_extent_offset(leaf, fi);
8359 if (dback->disk_bytenr + offset +
8360 btrfs_file_extent_num_bytes(leaf, fi) >
8361 entry->bytenr + entry->bytes) {
8362 fprintf(stderr, "Ref is past the entry end, please "
8363 "take a btrfs-image of this file system and "
8364 "send it to a btrfs developer, ref %Lu\n",
8365 dback->disk_bytenr);
8370 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8371 btrfs_set_file_extent_offset(leaf, fi, offset);
8372 } else if (dback->disk_bytenr < entry->bytenr) {
8375 offset = btrfs_file_extent_offset(leaf, fi);
8376 if (dback->disk_bytenr + offset < entry->bytenr) {
8377 fprintf(stderr, "Ref is before the entry start, please"
8378 " take a btrfs-image of this file system and "
8379 "send it to a btrfs developer, ref %Lu\n",
8380 dback->disk_bytenr);
8385 offset += dback->disk_bytenr;
8386 offset -= entry->bytenr;
8387 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8388 btrfs_set_file_extent_offset(leaf, fi, offset);
8391 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8394 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8395 * only do this if we aren't using compression, otherwise it's a
8398 if (!btrfs_file_extent_compression(leaf, fi))
8399 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8401 printf("ram bytes may be wrong?\n");
8402 btrfs_mark_buffer_dirty(leaf);
8404 err = btrfs_commit_transaction(trans, root);
8405 btrfs_release_path(path);
8406 return ret ? ret : err;
8409 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8410 struct extent_record *rec)
8412 struct extent_backref *back;
8413 struct data_backref *dback;
8414 struct extent_entry *entry, *best = NULL;
8417 int broken_entries = 0;
8422 * Metadata is easy and the backrefs should always agree on bytenr and
8423 * size, if not we've got bigger issues.
8428 list_for_each_entry(back, &rec->backrefs, list) {
8429 if (back->full_backref || !back->is_data)
8432 dback = to_data_backref(back);
8435 * We only pay attention to backrefs that we found a real
8438 if (dback->found_ref == 0)
8442 * For now we only catch when the bytes don't match, not the
8443 * bytenr. We can easily do this at the same time, but I want
8444 * to have a fs image to test on before we just add repair
8445 * functionality willy-nilly so we know we won't screw up the
8449 entry = find_entry(&entries, dback->disk_bytenr,
8452 entry = malloc(sizeof(struct extent_entry));
8457 memset(entry, 0, sizeof(*entry));
8458 entry->bytenr = dback->disk_bytenr;
8459 entry->bytes = dback->bytes;
8460 list_add_tail(&entry->list, &entries);
8465 * If we only have on entry we may think the entries agree when
8466 * in reality they don't so we have to do some extra checking.
8468 if (dback->disk_bytenr != rec->start ||
8469 dback->bytes != rec->nr || back->broken)
8480 /* Yay all the backrefs agree, carry on good sir */
8481 if (nr_entries <= 1 && !mismatch)
8484 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8485 "%Lu\n", rec->start);
8488 * First we want to see if the backrefs can agree amongst themselves who
8489 * is right, so figure out which one of the entries has the highest
8492 best = find_most_right_entry(&entries);
8495 * Ok so we may have an even split between what the backrefs think, so
8496 * this is where we use the extent ref to see what it thinks.
8499 entry = find_entry(&entries, rec->start, rec->nr);
8500 if (!entry && (!broken_entries || !rec->found_rec)) {
8501 fprintf(stderr, "Backrefs don't agree with each other "
8502 "and extent record doesn't agree with anybody,"
8503 " so we can't fix bytenr %Lu bytes %Lu\n",
8504 rec->start, rec->nr);
8507 } else if (!entry) {
8509 * Ok our backrefs were broken, we'll assume this is the
8510 * correct value and add an entry for this range.
8512 entry = malloc(sizeof(struct extent_entry));
8517 memset(entry, 0, sizeof(*entry));
8518 entry->bytenr = rec->start;
8519 entry->bytes = rec->nr;
8520 list_add_tail(&entry->list, &entries);
8524 best = find_most_right_entry(&entries);
8526 fprintf(stderr, "Backrefs and extent record evenly "
8527 "split on who is right, this is going to "
8528 "require user input to fix bytenr %Lu bytes "
8529 "%Lu\n", rec->start, rec->nr);
8536 * I don't think this can happen currently as we'll abort() if we catch
8537 * this case higher up, but in case somebody removes that we still can't
8538 * deal with it properly here yet, so just bail out of that's the case.
8540 if (best->bytenr != rec->start) {
8541 fprintf(stderr, "Extent start and backref starts don't match, "
8542 "please use btrfs-image on this file system and send "
8543 "it to a btrfs developer so they can make fsck fix "
8544 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8545 rec->start, rec->nr);
8551 * Ok great we all agreed on an extent record, let's go find the real
8552 * references and fix up the ones that don't match.
8554 list_for_each_entry(back, &rec->backrefs, list) {
8555 if (back->full_backref || !back->is_data)
8558 dback = to_data_backref(back);
8561 * Still ignoring backrefs that don't have a real ref attached
8564 if (dback->found_ref == 0)
8567 if (dback->bytes == best->bytes &&
8568 dback->disk_bytenr == best->bytenr)
8571 ret = repair_ref(info, path, dback, best);
8577 * Ok we messed with the actual refs, which means we need to drop our
8578 * entire cache and go back and rescan. I know this is a huge pain and
8579 * adds a lot of extra work, but it's the only way to be safe. Once all
8580 * the backrefs agree we may not need to do anything to the extent
8585 while (!list_empty(&entries)) {
8586 entry = list_entry(entries.next, struct extent_entry, list);
8587 list_del_init(&entry->list);
8593 static int process_duplicates(struct cache_tree *extent_cache,
8594 struct extent_record *rec)
8596 struct extent_record *good, *tmp;
8597 struct cache_extent *cache;
8601 * If we found a extent record for this extent then return, or if we
8602 * have more than one duplicate we are likely going to need to delete
8605 if (rec->found_rec || rec->num_duplicates > 1)
8608 /* Shouldn't happen but just in case */
8609 BUG_ON(!rec->num_duplicates);
8612 * So this happens if we end up with a backref that doesn't match the
8613 * actual extent entry. So either the backref is bad or the extent
8614 * entry is bad. Either way we want to have the extent_record actually
8615 * reflect what we found in the extent_tree, so we need to take the
8616 * duplicate out and use that as the extent_record since the only way we
8617 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8619 remove_cache_extent(extent_cache, &rec->cache);
8621 good = to_extent_record(rec->dups.next);
8622 list_del_init(&good->list);
8623 INIT_LIST_HEAD(&good->backrefs);
8624 INIT_LIST_HEAD(&good->dups);
8625 good->cache.start = good->start;
8626 good->cache.size = good->nr;
8627 good->content_checked = 0;
8628 good->owner_ref_checked = 0;
8629 good->num_duplicates = 0;
8630 good->refs = rec->refs;
8631 list_splice_init(&rec->backrefs, &good->backrefs);
8633 cache = lookup_cache_extent(extent_cache, good->start,
8637 tmp = container_of(cache, struct extent_record, cache);
8640 * If we find another overlapping extent and it's found_rec is
8641 * set then it's a duplicate and we need to try and delete
8644 if (tmp->found_rec || tmp->num_duplicates > 0) {
8645 if (list_empty(&good->list))
8646 list_add_tail(&good->list,
8647 &duplicate_extents);
8648 good->num_duplicates += tmp->num_duplicates + 1;
8649 list_splice_init(&tmp->dups, &good->dups);
8650 list_del_init(&tmp->list);
8651 list_add_tail(&tmp->list, &good->dups);
8652 remove_cache_extent(extent_cache, &tmp->cache);
8657 * Ok we have another non extent item backed extent rec, so lets
8658 * just add it to this extent and carry on like we did above.
8660 good->refs += tmp->refs;
8661 list_splice_init(&tmp->backrefs, &good->backrefs);
8662 remove_cache_extent(extent_cache, &tmp->cache);
8665 ret = insert_cache_extent(extent_cache, &good->cache);
8668 return good->num_duplicates ? 0 : 1;
8671 static int delete_duplicate_records(struct btrfs_root *root,
8672 struct extent_record *rec)
8674 struct btrfs_trans_handle *trans;
8675 LIST_HEAD(delete_list);
8676 struct btrfs_path path;
8677 struct extent_record *tmp, *good, *n;
8680 struct btrfs_key key;
8682 btrfs_init_path(&path);
8685 /* Find the record that covers all of the duplicates. */
8686 list_for_each_entry(tmp, &rec->dups, list) {
8687 if (good->start < tmp->start)
8689 if (good->nr > tmp->nr)
8692 if (tmp->start + tmp->nr < good->start + good->nr) {
8693 fprintf(stderr, "Ok we have overlapping extents that "
8694 "aren't completely covered by each other, this "
8695 "is going to require more careful thought. "
8696 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8697 tmp->start, tmp->nr, good->start, good->nr);
8704 list_add_tail(&rec->list, &delete_list);
8706 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8709 list_move_tail(&tmp->list, &delete_list);
8712 root = root->fs_info->extent_root;
8713 trans = btrfs_start_transaction(root, 1);
8714 if (IS_ERR(trans)) {
8715 ret = PTR_ERR(trans);
8719 list_for_each_entry(tmp, &delete_list, list) {
8720 if (tmp->found_rec == 0)
8722 key.objectid = tmp->start;
8723 key.type = BTRFS_EXTENT_ITEM_KEY;
8724 key.offset = tmp->nr;
8726 /* Shouldn't happen but just in case */
8727 if (tmp->metadata) {
8728 fprintf(stderr, "Well this shouldn't happen, extent "
8729 "record overlaps but is metadata? "
8730 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8734 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8740 ret = btrfs_del_item(trans, root, &path);
8743 btrfs_release_path(&path);
8746 err = btrfs_commit_transaction(trans, root);
8750 while (!list_empty(&delete_list)) {
8751 tmp = to_extent_record(delete_list.next);
8752 list_del_init(&tmp->list);
8758 while (!list_empty(&rec->dups)) {
8759 tmp = to_extent_record(rec->dups.next);
8760 list_del_init(&tmp->list);
8764 btrfs_release_path(&path);
8766 if (!ret && !nr_del)
8767 rec->num_duplicates = 0;
8769 return ret ? ret : nr_del;
8772 static int find_possible_backrefs(struct btrfs_fs_info *info,
8773 struct btrfs_path *path,
8774 struct cache_tree *extent_cache,
8775 struct extent_record *rec)
8777 struct btrfs_root *root;
8778 struct extent_backref *back;
8779 struct data_backref *dback;
8780 struct cache_extent *cache;
8781 struct btrfs_file_extent_item *fi;
8782 struct btrfs_key key;
8786 list_for_each_entry(back, &rec->backrefs, list) {
8787 /* Don't care about full backrefs (poor unloved backrefs) */
8788 if (back->full_backref || !back->is_data)
8791 dback = to_data_backref(back);
8793 /* We found this one, we don't need to do a lookup */
8794 if (dback->found_ref)
8797 key.objectid = dback->root;
8798 key.type = BTRFS_ROOT_ITEM_KEY;
8799 key.offset = (u64)-1;
8801 root = btrfs_read_fs_root(info, &key);
8803 /* No root, definitely a bad ref, skip */
8804 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8806 /* Other err, exit */
8808 return PTR_ERR(root);
8810 key.objectid = dback->owner;
8811 key.type = BTRFS_EXTENT_DATA_KEY;
8812 key.offset = dback->offset;
8813 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8815 btrfs_release_path(path);
8818 /* Didn't find it, we can carry on */
8823 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8824 struct btrfs_file_extent_item);
8825 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8826 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8827 btrfs_release_path(path);
8828 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8830 struct extent_record *tmp;
8831 tmp = container_of(cache, struct extent_record, cache);
8834 * If we found an extent record for the bytenr for this
8835 * particular backref then we can't add it to our
8836 * current extent record. We only want to add backrefs
8837 * that don't have a corresponding extent item in the
8838 * extent tree since they likely belong to this record
8839 * and we need to fix it if it doesn't match bytenrs.
8845 dback->found_ref += 1;
8846 dback->disk_bytenr = bytenr;
8847 dback->bytes = bytes;
8850 * Set this so the verify backref code knows not to trust the
8851 * values in this backref.
8860 * Record orphan data ref into corresponding root.
8862 * Return 0 if the extent item contains data ref and recorded.
8863 * Return 1 if the extent item contains no useful data ref
8864 * On that case, it may contains only shared_dataref or metadata backref
8865 * or the file extent exists(this should be handled by the extent bytenr
8867 * Return <0 if something goes wrong.
8869 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8870 struct extent_record *rec)
8872 struct btrfs_key key;
8873 struct btrfs_root *dest_root;
8874 struct extent_backref *back;
8875 struct data_backref *dback;
8876 struct orphan_data_extent *orphan;
8877 struct btrfs_path path;
8878 int recorded_data_ref = 0;
8883 btrfs_init_path(&path);
8884 list_for_each_entry(back, &rec->backrefs, list) {
8885 if (back->full_backref || !back->is_data ||
8886 !back->found_extent_tree)
8888 dback = to_data_backref(back);
8889 if (dback->found_ref)
8891 key.objectid = dback->root;
8892 key.type = BTRFS_ROOT_ITEM_KEY;
8893 key.offset = (u64)-1;
8895 dest_root = btrfs_read_fs_root(fs_info, &key);
8897 /* For non-exist root we just skip it */
8898 if (IS_ERR(dest_root) || !dest_root)
8901 key.objectid = dback->owner;
8902 key.type = BTRFS_EXTENT_DATA_KEY;
8903 key.offset = dback->offset;
8905 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8906 btrfs_release_path(&path);
8908 * For ret < 0, it's OK since the fs-tree may be corrupted,
8909 * we need to record it for inode/file extent rebuild.
8910 * For ret > 0, we record it only for file extent rebuild.
8911 * For ret == 0, the file extent exists but only bytenr
8912 * mismatch, let the original bytenr fix routine to handle,
8918 orphan = malloc(sizeof(*orphan));
8923 INIT_LIST_HEAD(&orphan->list);
8924 orphan->root = dback->root;
8925 orphan->objectid = dback->owner;
8926 orphan->offset = dback->offset;
8927 orphan->disk_bytenr = rec->cache.start;
8928 orphan->disk_len = rec->cache.size;
8929 list_add(&dest_root->orphan_data_extents, &orphan->list);
8930 recorded_data_ref = 1;
8933 btrfs_release_path(&path);
8935 return !recorded_data_ref;
8941 * when an incorrect extent item is found, this will delete
8942 * all of the existing entries for it and recreate them
8943 * based on what the tree scan found.
8945 static int fixup_extent_refs(struct btrfs_fs_info *info,
8946 struct cache_tree *extent_cache,
8947 struct extent_record *rec)
8949 struct btrfs_trans_handle *trans = NULL;
8951 struct btrfs_path path;
8952 struct list_head *cur = rec->backrefs.next;
8953 struct cache_extent *cache;
8954 struct extent_backref *back;
8958 if (rec->flag_block_full_backref)
8959 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
8961 btrfs_init_path(&path);
8962 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
8964 * Sometimes the backrefs themselves are so broken they don't
8965 * get attached to any meaningful rec, so first go back and
8966 * check any of our backrefs that we couldn't find and throw
8967 * them into the list if we find the backref so that
8968 * verify_backrefs can figure out what to do.
8970 ret = find_possible_backrefs(info, &path, extent_cache, rec);
8975 /* step one, make sure all of the backrefs agree */
8976 ret = verify_backrefs(info, &path, rec);
8980 trans = btrfs_start_transaction(info->extent_root, 1);
8981 if (IS_ERR(trans)) {
8982 ret = PTR_ERR(trans);
8986 /* step two, delete all the existing records */
8987 ret = delete_extent_records(trans, info->extent_root, &path,
8993 /* was this block corrupt? If so, don't add references to it */
8994 cache = lookup_cache_extent(info->corrupt_blocks,
8995 rec->start, rec->max_size);
9001 /* step three, recreate all the refs we did find */
9002 while(cur != &rec->backrefs) {
9003 back = to_extent_backref(cur);
9007 * if we didn't find any references, don't create a
9010 if (!back->found_ref)
9013 rec->bad_full_backref = 0;
9014 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
9022 int err = btrfs_commit_transaction(trans, info->extent_root);
9028 fprintf(stderr, "Repaired extent references for %llu\n",
9029 (unsigned long long)rec->start);
9031 btrfs_release_path(&path);
9035 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9036 struct extent_record *rec)
9038 struct btrfs_trans_handle *trans;
9039 struct btrfs_root *root = fs_info->extent_root;
9040 struct btrfs_path path;
9041 struct btrfs_extent_item *ei;
9042 struct btrfs_key key;
9046 key.objectid = rec->start;
9047 if (rec->metadata) {
9048 key.type = BTRFS_METADATA_ITEM_KEY;
9049 key.offset = rec->info_level;
9051 key.type = BTRFS_EXTENT_ITEM_KEY;
9052 key.offset = rec->max_size;
9055 trans = btrfs_start_transaction(root, 0);
9057 return PTR_ERR(trans);
9059 btrfs_init_path(&path);
9060 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9062 btrfs_release_path(&path);
9063 btrfs_commit_transaction(trans, root);
9066 fprintf(stderr, "Didn't find extent for %llu\n",
9067 (unsigned long long)rec->start);
9068 btrfs_release_path(&path);
9069 btrfs_commit_transaction(trans, root);
9073 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9074 struct btrfs_extent_item);
9075 flags = btrfs_extent_flags(path.nodes[0], ei);
9076 if (rec->flag_block_full_backref) {
9077 fprintf(stderr, "setting full backref on %llu\n",
9078 (unsigned long long)key.objectid);
9079 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9081 fprintf(stderr, "clearing full backref on %llu\n",
9082 (unsigned long long)key.objectid);
9083 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9085 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9086 btrfs_mark_buffer_dirty(path.nodes[0]);
9087 btrfs_release_path(&path);
9088 ret = btrfs_commit_transaction(trans, root);
9090 fprintf(stderr, "Repaired extent flags for %llu\n",
9091 (unsigned long long)rec->start);
9096 /* right now we only prune from the extent allocation tree */
9097 static int prune_one_block(struct btrfs_trans_handle *trans,
9098 struct btrfs_fs_info *info,
9099 struct btrfs_corrupt_block *corrupt)
9102 struct btrfs_path path;
9103 struct extent_buffer *eb;
9107 int level = corrupt->level + 1;
9109 btrfs_init_path(&path);
9111 /* we want to stop at the parent to our busted block */
9112 path.lowest_level = level;
9114 ret = btrfs_search_slot(trans, info->extent_root,
9115 &corrupt->key, &path, -1, 1);
9120 eb = path.nodes[level];
9127 * hopefully the search gave us the block we want to prune,
9128 * lets try that first
9130 slot = path.slots[level];
9131 found = btrfs_node_blockptr(eb, slot);
9132 if (found == corrupt->cache.start)
9135 nritems = btrfs_header_nritems(eb);
9137 /* the search failed, lets scan this node and hope we find it */
9138 for (slot = 0; slot < nritems; slot++) {
9139 found = btrfs_node_blockptr(eb, slot);
9140 if (found == corrupt->cache.start)
9144 * we couldn't find the bad block. TODO, search all the nodes for pointers
9147 if (eb == info->extent_root->node) {
9152 btrfs_release_path(&path);
9157 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9158 ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
9161 btrfs_release_path(&path);
9165 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9167 struct btrfs_trans_handle *trans = NULL;
9168 struct cache_extent *cache;
9169 struct btrfs_corrupt_block *corrupt;
9172 cache = search_cache_extent(info->corrupt_blocks, 0);
9176 trans = btrfs_start_transaction(info->extent_root, 1);
9178 return PTR_ERR(trans);
9180 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9181 prune_one_block(trans, info, corrupt);
9182 remove_cache_extent(info->corrupt_blocks, cache);
9185 return btrfs_commit_transaction(trans, info->extent_root);
9189 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9191 struct btrfs_block_group_cache *cache;
9196 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9197 &start, &end, EXTENT_DIRTY);
9200 clear_extent_dirty(&fs_info->free_space_cache, start, end);
9205 cache = btrfs_lookup_first_block_group(fs_info, start);
9210 start = cache->key.objectid + cache->key.offset;
9214 static int check_extent_refs(struct btrfs_root *root,
9215 struct cache_tree *extent_cache)
9217 struct extent_record *rec;
9218 struct cache_extent *cache;
9224 * if we're doing a repair, we have to make sure
9225 * we don't allocate from the problem extents.
9226 * In the worst case, this will be all the
9229 cache = search_cache_extent(extent_cache, 0);
9231 rec = container_of(cache, struct extent_record, cache);
9232 set_extent_dirty(root->fs_info->excluded_extents,
9234 rec->start + rec->max_size - 1);
9235 cache = next_cache_extent(cache);
9238 /* pin down all the corrupted blocks too */
9239 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9241 set_extent_dirty(root->fs_info->excluded_extents,
9243 cache->start + cache->size - 1);
9244 cache = next_cache_extent(cache);
9246 prune_corrupt_blocks(root->fs_info);
9247 reset_cached_block_groups(root->fs_info);
9250 reset_cached_block_groups(root->fs_info);
9253 * We need to delete any duplicate entries we find first otherwise we
9254 * could mess up the extent tree when we have backrefs that actually
9255 * belong to a different extent item and not the weird duplicate one.
9257 while (repair && !list_empty(&duplicate_extents)) {
9258 rec = to_extent_record(duplicate_extents.next);
9259 list_del_init(&rec->list);
9261 /* Sometimes we can find a backref before we find an actual
9262 * extent, so we need to process it a little bit to see if there
9263 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9264 * if this is a backref screwup. If we need to delete stuff
9265 * process_duplicates() will return 0, otherwise it will return
9268 if (process_duplicates(extent_cache, rec))
9270 ret = delete_duplicate_records(root, rec);
9274 * delete_duplicate_records will return the number of entries
9275 * deleted, so if it's greater than 0 then we know we actually
9276 * did something and we need to remove.
9289 cache = search_cache_extent(extent_cache, 0);
9292 rec = container_of(cache, struct extent_record, cache);
9293 if (rec->num_duplicates) {
9294 fprintf(stderr, "extent item %llu has multiple extent "
9295 "items\n", (unsigned long long)rec->start);
9299 if (rec->refs != rec->extent_item_refs) {
9300 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9301 (unsigned long long)rec->start,
9302 (unsigned long long)rec->nr);
9303 fprintf(stderr, "extent item %llu, found %llu\n",
9304 (unsigned long long)rec->extent_item_refs,
9305 (unsigned long long)rec->refs);
9306 ret = record_orphan_data_extents(root->fs_info, rec);
9312 if (all_backpointers_checked(rec, 1)) {
9313 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9314 (unsigned long long)rec->start,
9315 (unsigned long long)rec->nr);
9319 if (!rec->owner_ref_checked) {
9320 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9321 (unsigned long long)rec->start,
9322 (unsigned long long)rec->nr);
9327 if (repair && fix) {
9328 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9334 if (rec->bad_full_backref) {
9335 fprintf(stderr, "bad full backref, on [%llu]\n",
9336 (unsigned long long)rec->start);
9338 ret = fixup_extent_flags(root->fs_info, rec);
9346 * Although it's not a extent ref's problem, we reuse this
9347 * routine for error reporting.
9348 * No repair function yet.
9350 if (rec->crossing_stripes) {
9352 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9353 rec->start, rec->start + rec->max_size);
9357 if (rec->wrong_chunk_type) {
9359 "bad extent [%llu, %llu), type mismatch with chunk\n",
9360 rec->start, rec->start + rec->max_size);
9364 remove_cache_extent(extent_cache, cache);
9365 free_all_extent_backrefs(rec);
9366 if (!init_extent_tree && repair && (!cur_err || fix))
9367 clear_extent_dirty(root->fs_info->excluded_extents,
9369 rec->start + rec->max_size - 1);
9374 if (ret && ret != -EAGAIN) {
9375 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9378 struct btrfs_trans_handle *trans;
9380 root = root->fs_info->extent_root;
9381 trans = btrfs_start_transaction(root, 1);
9382 if (IS_ERR(trans)) {
9383 ret = PTR_ERR(trans);
9387 btrfs_fix_block_accounting(trans, root);
9388 ret = btrfs_commit_transaction(trans, root);
9397 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9401 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9402 stripe_size = length;
9403 stripe_size /= num_stripes;
9404 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9405 stripe_size = length * 2;
9406 stripe_size /= num_stripes;
9407 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9408 stripe_size = length;
9409 stripe_size /= (num_stripes - 1);
9410 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9411 stripe_size = length;
9412 stripe_size /= (num_stripes - 2);
9414 stripe_size = length;
9420 * Check the chunk with its block group/dev list ref:
9421 * Return 0 if all refs seems valid.
9422 * Return 1 if part of refs seems valid, need later check for rebuild ref
9423 * like missing block group and needs to search extent tree to rebuild them.
9424 * Return -1 if essential refs are missing and unable to rebuild.
9426 static int check_chunk_refs(struct chunk_record *chunk_rec,
9427 struct block_group_tree *block_group_cache,
9428 struct device_extent_tree *dev_extent_cache,
9431 struct cache_extent *block_group_item;
9432 struct block_group_record *block_group_rec;
9433 struct cache_extent *dev_extent_item;
9434 struct device_extent_record *dev_extent_rec;
9438 int metadump_v2 = 0;
9442 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9445 if (block_group_item) {
9446 block_group_rec = container_of(block_group_item,
9447 struct block_group_record,
9449 if (chunk_rec->length != block_group_rec->offset ||
9450 chunk_rec->offset != block_group_rec->objectid ||
9452 chunk_rec->type_flags != block_group_rec->flags)) {
9455 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9456 chunk_rec->objectid,
9461 chunk_rec->type_flags,
9462 block_group_rec->objectid,
9463 block_group_rec->type,
9464 block_group_rec->offset,
9465 block_group_rec->offset,
9466 block_group_rec->objectid,
9467 block_group_rec->flags);
9470 list_del_init(&block_group_rec->list);
9471 chunk_rec->bg_rec = block_group_rec;
9476 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9477 chunk_rec->objectid,
9482 chunk_rec->type_flags);
9489 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9490 chunk_rec->num_stripes);
9491 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9492 devid = chunk_rec->stripes[i].devid;
9493 offset = chunk_rec->stripes[i].offset;
9494 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9495 devid, offset, length);
9496 if (dev_extent_item) {
9497 dev_extent_rec = container_of(dev_extent_item,
9498 struct device_extent_record,
9500 if (dev_extent_rec->objectid != devid ||
9501 dev_extent_rec->offset != offset ||
9502 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9503 dev_extent_rec->length != length) {
9506 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9507 chunk_rec->objectid,
9510 chunk_rec->stripes[i].devid,
9511 chunk_rec->stripes[i].offset,
9512 dev_extent_rec->objectid,
9513 dev_extent_rec->offset,
9514 dev_extent_rec->length);
9517 list_move(&dev_extent_rec->chunk_list,
9518 &chunk_rec->dextents);
9523 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9524 chunk_rec->objectid,
9527 chunk_rec->stripes[i].devid,
9528 chunk_rec->stripes[i].offset);
9535 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9536 int check_chunks(struct cache_tree *chunk_cache,
9537 struct block_group_tree *block_group_cache,
9538 struct device_extent_tree *dev_extent_cache,
9539 struct list_head *good, struct list_head *bad,
9540 struct list_head *rebuild, int silent)
9542 struct cache_extent *chunk_item;
9543 struct chunk_record *chunk_rec;
9544 struct block_group_record *bg_rec;
9545 struct device_extent_record *dext_rec;
9549 chunk_item = first_cache_extent(chunk_cache);
9550 while (chunk_item) {
9551 chunk_rec = container_of(chunk_item, struct chunk_record,
9553 err = check_chunk_refs(chunk_rec, block_group_cache,
9554 dev_extent_cache, silent);
9557 if (err == 0 && good)
9558 list_add_tail(&chunk_rec->list, good);
9559 if (err > 0 && rebuild)
9560 list_add_tail(&chunk_rec->list, rebuild);
9562 list_add_tail(&chunk_rec->list, bad);
9563 chunk_item = next_cache_extent(chunk_item);
9566 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9569 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9577 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9581 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9592 static int check_device_used(struct device_record *dev_rec,
9593 struct device_extent_tree *dext_cache)
9595 struct cache_extent *cache;
9596 struct device_extent_record *dev_extent_rec;
9599 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9601 dev_extent_rec = container_of(cache,
9602 struct device_extent_record,
9604 if (dev_extent_rec->objectid != dev_rec->devid)
9607 list_del_init(&dev_extent_rec->device_list);
9608 total_byte += dev_extent_rec->length;
9609 cache = next_cache_extent(cache);
9612 if (total_byte != dev_rec->byte_used) {
9614 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9615 total_byte, dev_rec->byte_used, dev_rec->objectid,
9616 dev_rec->type, dev_rec->offset);
9623 /* check btrfs_dev_item -> btrfs_dev_extent */
9624 static int check_devices(struct rb_root *dev_cache,
9625 struct device_extent_tree *dev_extent_cache)
9627 struct rb_node *dev_node;
9628 struct device_record *dev_rec;
9629 struct device_extent_record *dext_rec;
9633 dev_node = rb_first(dev_cache);
9635 dev_rec = container_of(dev_node, struct device_record, node);
9636 err = check_device_used(dev_rec, dev_extent_cache);
9640 dev_node = rb_next(dev_node);
9642 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9645 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9646 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9653 static int add_root_item_to_list(struct list_head *head,
9654 u64 objectid, u64 bytenr, u64 last_snapshot,
9655 u8 level, u8 drop_level,
9656 int level_size, struct btrfs_key *drop_key)
9659 struct root_item_record *ri_rec;
9660 ri_rec = malloc(sizeof(*ri_rec));
9663 ri_rec->bytenr = bytenr;
9664 ri_rec->objectid = objectid;
9665 ri_rec->level = level;
9666 ri_rec->level_size = level_size;
9667 ri_rec->drop_level = drop_level;
9668 ri_rec->last_snapshot = last_snapshot;
9670 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9671 list_add_tail(&ri_rec->list, head);
9676 static void free_root_item_list(struct list_head *list)
9678 struct root_item_record *ri_rec;
9680 while (!list_empty(list)) {
9681 ri_rec = list_first_entry(list, struct root_item_record,
9683 list_del_init(&ri_rec->list);
9688 static int deal_root_from_list(struct list_head *list,
9689 struct btrfs_root *root,
9690 struct block_info *bits,
9692 struct cache_tree *pending,
9693 struct cache_tree *seen,
9694 struct cache_tree *reada,
9695 struct cache_tree *nodes,
9696 struct cache_tree *extent_cache,
9697 struct cache_tree *chunk_cache,
9698 struct rb_root *dev_cache,
9699 struct block_group_tree *block_group_cache,
9700 struct device_extent_tree *dev_extent_cache)
9705 while (!list_empty(list)) {
9706 struct root_item_record *rec;
9707 struct extent_buffer *buf;
9708 rec = list_entry(list->next,
9709 struct root_item_record, list);
9711 buf = read_tree_block(root->fs_info->tree_root,
9712 rec->bytenr, rec->level_size, 0);
9713 if (!extent_buffer_uptodate(buf)) {
9714 free_extent_buffer(buf);
9718 ret = add_root_to_pending(buf, extent_cache, pending,
9719 seen, nodes, rec->objectid);
9723 * To rebuild extent tree, we need deal with snapshot
9724 * one by one, otherwise we deal with node firstly which
9725 * can maximize readahead.
9728 ret = run_next_block(root, bits, bits_nr, &last,
9729 pending, seen, reada, nodes,
9730 extent_cache, chunk_cache,
9731 dev_cache, block_group_cache,
9732 dev_extent_cache, rec);
9736 free_extent_buffer(buf);
9737 list_del(&rec->list);
9743 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9744 reada, nodes, extent_cache, chunk_cache,
9745 dev_cache, block_group_cache,
9746 dev_extent_cache, NULL);
9756 static int check_chunks_and_extents(struct btrfs_root *root)
9758 struct rb_root dev_cache;
9759 struct cache_tree chunk_cache;
9760 struct block_group_tree block_group_cache;
9761 struct device_extent_tree dev_extent_cache;
9762 struct cache_tree extent_cache;
9763 struct cache_tree seen;
9764 struct cache_tree pending;
9765 struct cache_tree reada;
9766 struct cache_tree nodes;
9767 struct extent_io_tree excluded_extents;
9768 struct cache_tree corrupt_blocks;
9769 struct btrfs_path path;
9770 struct btrfs_key key;
9771 struct btrfs_key found_key;
9773 struct block_info *bits;
9775 struct extent_buffer *leaf;
9777 struct btrfs_root_item ri;
9778 struct list_head dropping_trees;
9779 struct list_head normal_trees;
9780 struct btrfs_root *root1;
9785 dev_cache = RB_ROOT;
9786 cache_tree_init(&chunk_cache);
9787 block_group_tree_init(&block_group_cache);
9788 device_extent_tree_init(&dev_extent_cache);
9790 cache_tree_init(&extent_cache);
9791 cache_tree_init(&seen);
9792 cache_tree_init(&pending);
9793 cache_tree_init(&nodes);
9794 cache_tree_init(&reada);
9795 cache_tree_init(&corrupt_blocks);
9796 extent_io_tree_init(&excluded_extents);
9797 INIT_LIST_HEAD(&dropping_trees);
9798 INIT_LIST_HEAD(&normal_trees);
9801 root->fs_info->excluded_extents = &excluded_extents;
9802 root->fs_info->fsck_extent_cache = &extent_cache;
9803 root->fs_info->free_extent_hook = free_extent_hook;
9804 root->fs_info->corrupt_blocks = &corrupt_blocks;
9808 bits = malloc(bits_nr * sizeof(struct block_info));
9814 if (ctx.progress_enabled) {
9815 ctx.tp = TASK_EXTENTS;
9816 task_start(ctx.info);
9820 root1 = root->fs_info->tree_root;
9821 level = btrfs_header_level(root1->node);
9822 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9823 root1->node->start, 0, level, 0,
9824 root1->nodesize, NULL);
9827 root1 = root->fs_info->chunk_root;
9828 level = btrfs_header_level(root1->node);
9829 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9830 root1->node->start, 0, level, 0,
9831 root1->nodesize, NULL);
9834 btrfs_init_path(&path);
9837 key.type = BTRFS_ROOT_ITEM_KEY;
9838 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9843 leaf = path.nodes[0];
9844 slot = path.slots[0];
9845 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9846 ret = btrfs_next_leaf(root, &path);
9849 leaf = path.nodes[0];
9850 slot = path.slots[0];
9852 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9853 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9854 unsigned long offset;
9857 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9858 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9859 last_snapshot = btrfs_root_last_snapshot(&ri);
9860 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9861 level = btrfs_root_level(&ri);
9862 level_size = root->nodesize;
9863 ret = add_root_item_to_list(&normal_trees,
9865 btrfs_root_bytenr(&ri),
9866 last_snapshot, level,
9867 0, level_size, NULL);
9871 level = btrfs_root_level(&ri);
9872 level_size = root->nodesize;
9873 objectid = found_key.objectid;
9874 btrfs_disk_key_to_cpu(&found_key,
9876 ret = add_root_item_to_list(&dropping_trees,
9878 btrfs_root_bytenr(&ri),
9879 last_snapshot, level,
9881 level_size, &found_key);
9888 btrfs_release_path(&path);
9891 * check_block can return -EAGAIN if it fixes something, please keep
9892 * this in mind when dealing with return values from these functions, if
9893 * we get -EAGAIN we want to fall through and restart the loop.
9895 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9896 &seen, &reada, &nodes, &extent_cache,
9897 &chunk_cache, &dev_cache, &block_group_cache,
9904 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9905 &pending, &seen, &reada, &nodes,
9906 &extent_cache, &chunk_cache, &dev_cache,
9907 &block_group_cache, &dev_extent_cache);
9914 ret = check_chunks(&chunk_cache, &block_group_cache,
9915 &dev_extent_cache, NULL, NULL, NULL, 0);
9922 ret = check_extent_refs(root, &extent_cache);
9929 ret = check_devices(&dev_cache, &dev_extent_cache);
9934 task_stop(ctx.info);
9936 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9937 extent_io_tree_cleanup(&excluded_extents);
9938 root->fs_info->fsck_extent_cache = NULL;
9939 root->fs_info->free_extent_hook = NULL;
9940 root->fs_info->corrupt_blocks = NULL;
9941 root->fs_info->excluded_extents = NULL;
9944 free_chunk_cache_tree(&chunk_cache);
9945 free_device_cache_tree(&dev_cache);
9946 free_block_group_tree(&block_group_cache);
9947 free_device_extent_tree(&dev_extent_cache);
9948 free_extent_cache_tree(&seen);
9949 free_extent_cache_tree(&pending);
9950 free_extent_cache_tree(&reada);
9951 free_extent_cache_tree(&nodes);
9954 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
9955 free_extent_cache_tree(&seen);
9956 free_extent_cache_tree(&pending);
9957 free_extent_cache_tree(&reada);
9958 free_extent_cache_tree(&nodes);
9959 free_chunk_cache_tree(&chunk_cache);
9960 free_block_group_tree(&block_group_cache);
9961 free_device_cache_tree(&dev_cache);
9962 free_device_extent_tree(&dev_extent_cache);
9963 free_extent_record_cache(&extent_cache);
9964 free_root_item_list(&normal_trees);
9965 free_root_item_list(&dropping_trees);
9966 extent_io_tree_cleanup(&excluded_extents);
9971 * Check backrefs of a tree block given by @bytenr or @eb.
9973 * @root: the root containing the @bytenr or @eb
9974 * @eb: tree block extent buffer, can be NULL
9975 * @bytenr: bytenr of the tree block to search
9976 * @level: tree level of the tree block
9977 * @owner: owner of the tree block
9979 * Return >0 for any error found and output error message
9980 * Return 0 for no error found
9982 static int check_tree_block_ref(struct btrfs_root *root,
9983 struct extent_buffer *eb, u64 bytenr,
9984 int level, u64 owner)
9986 struct btrfs_key key;
9987 struct btrfs_root *extent_root = root->fs_info->extent_root;
9988 struct btrfs_path path;
9989 struct btrfs_extent_item *ei;
9990 struct btrfs_extent_inline_ref *iref;
9991 struct extent_buffer *leaf;
9997 u32 nodesize = root->nodesize;
10000 int tree_reloc_root = 0;
10005 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
10006 btrfs_header_bytenr(root->node) == bytenr)
10007 tree_reloc_root = 1;
10009 btrfs_init_path(&path);
10010 key.objectid = bytenr;
10011 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
10012 key.type = BTRFS_METADATA_ITEM_KEY;
10014 key.type = BTRFS_EXTENT_ITEM_KEY;
10015 key.offset = (u64)-1;
10017 /* Search for the backref in extent tree */
10018 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10020 err |= BACKREF_MISSING;
10023 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10025 err |= BACKREF_MISSING;
10029 leaf = path.nodes[0];
10030 slot = path.slots[0];
10031 btrfs_item_key_to_cpu(leaf, &key, slot);
10033 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10035 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10036 skinny_level = (int)key.offset;
10037 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10039 struct btrfs_tree_block_info *info;
10041 info = (struct btrfs_tree_block_info *)(ei + 1);
10042 skinny_level = btrfs_tree_block_level(leaf, info);
10043 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10050 if (!(btrfs_extent_flags(leaf, ei) &
10051 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10053 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10054 key.objectid, nodesize,
10055 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10056 err = BACKREF_MISMATCH;
10058 header_gen = btrfs_header_generation(eb);
10059 extent_gen = btrfs_extent_generation(leaf, ei);
10060 if (header_gen != extent_gen) {
10062 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10063 key.objectid, nodesize, header_gen,
10065 err = BACKREF_MISMATCH;
10067 if (level != skinny_level) {
10069 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10070 key.objectid, nodesize, level, skinny_level);
10071 err = BACKREF_MISMATCH;
10073 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10075 "extent[%llu %u] is referred by other roots than %llu",
10076 key.objectid, nodesize, root->objectid);
10077 err = BACKREF_MISMATCH;
10082 * Iterate the extent/metadata item to find the exact backref
10084 item_size = btrfs_item_size_nr(leaf, slot);
10085 ptr = (unsigned long)iref;
10086 end = (unsigned long)ei + item_size;
10087 while (ptr < end) {
10088 iref = (struct btrfs_extent_inline_ref *)ptr;
10089 type = btrfs_extent_inline_ref_type(leaf, iref);
10090 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10092 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10093 (offset == root->objectid || offset == owner)) {
10095 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10097 * Backref of tree reloc root points to itself, no need
10098 * to check backref any more.
10100 if (tree_reloc_root)
10103 /* Check if the backref points to valid referencer */
10104 found_ref = !check_tree_block_ref(root, NULL,
10105 offset, level + 1, owner);
10110 ptr += btrfs_extent_inline_ref_size(type);
10114 * Inlined extent item doesn't have what we need, check
10115 * TREE_BLOCK_REF_KEY
10118 btrfs_release_path(&path);
10119 key.objectid = bytenr;
10120 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10121 key.offset = root->objectid;
10123 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10128 err |= BACKREF_MISSING;
10130 btrfs_release_path(&path);
10131 if (eb && (err & BACKREF_MISSING))
10132 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10133 bytenr, nodesize, owner, level);
10138 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10140 * Return >0 any error found and output error message
10141 * Return 0 for no error found
10143 static int check_extent_data_item(struct btrfs_root *root,
10144 struct extent_buffer *eb, int slot)
10146 struct btrfs_file_extent_item *fi;
10147 struct btrfs_path path;
10148 struct btrfs_root *extent_root = root->fs_info->extent_root;
10149 struct btrfs_key fi_key;
10150 struct btrfs_key dbref_key;
10151 struct extent_buffer *leaf;
10152 struct btrfs_extent_item *ei;
10153 struct btrfs_extent_inline_ref *iref;
10154 struct btrfs_extent_data_ref *dref;
10157 u64 disk_num_bytes;
10158 u64 extent_num_bytes;
10165 int found_dbackref = 0;
10169 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10170 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10172 /* Nothing to check for hole and inline data extents */
10173 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10174 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10177 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10178 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10179 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10181 /* Check unaligned disk_num_bytes and num_bytes */
10182 if (!IS_ALIGNED(disk_num_bytes, root->sectorsize)) {
10184 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10185 fi_key.objectid, fi_key.offset, disk_num_bytes,
10187 err |= BYTES_UNALIGNED;
10189 data_bytes_allocated += disk_num_bytes;
10191 if (!IS_ALIGNED(extent_num_bytes, root->sectorsize)) {
10193 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10194 fi_key.objectid, fi_key.offset, extent_num_bytes,
10196 err |= BYTES_UNALIGNED;
10198 data_bytes_referenced += extent_num_bytes;
10200 owner = btrfs_header_owner(eb);
10202 /* Check the extent item of the file extent in extent tree */
10203 btrfs_init_path(&path);
10204 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10205 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10206 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10208 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10210 err |= BACKREF_MISSING;
10214 leaf = path.nodes[0];
10215 slot = path.slots[0];
10216 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10218 extent_flags = btrfs_extent_flags(leaf, ei);
10220 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10222 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10223 disk_bytenr, disk_num_bytes,
10224 BTRFS_EXTENT_FLAG_DATA);
10225 err |= BACKREF_MISMATCH;
10228 /* Check data backref inside that extent item */
10229 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10230 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10231 ptr = (unsigned long)iref;
10232 end = (unsigned long)ei + item_size;
10233 while (ptr < end) {
10234 iref = (struct btrfs_extent_inline_ref *)ptr;
10235 type = btrfs_extent_inline_ref_type(leaf, iref);
10236 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10238 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10239 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10240 if (ref_root == owner || ref_root == root->objectid)
10241 found_dbackref = 1;
10242 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10243 found_dbackref = !check_tree_block_ref(root, NULL,
10244 btrfs_extent_inline_ref_offset(leaf, iref),
10248 if (found_dbackref)
10250 ptr += btrfs_extent_inline_ref_size(type);
10253 /* Didn't found inlined data backref, try EXTENT_DATA_REF_KEY */
10254 if (!found_dbackref) {
10255 btrfs_release_path(&path);
10257 btrfs_init_path(&path);
10258 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10259 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10260 dbref_key.offset = hash_extent_data_ref(root->objectid,
10261 fi_key.objectid, fi_key.offset);
10263 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10264 &dbref_key, &path, 0, 0);
10266 found_dbackref = 1;
10269 if (!found_dbackref)
10270 err |= BACKREF_MISSING;
10272 btrfs_release_path(&path);
10273 if (err & BACKREF_MISSING) {
10274 error("data extent[%llu %llu] backref lost",
10275 disk_bytenr, disk_num_bytes);
10281 * Get real tree block level for the case like shared block
10282 * Return >= 0 as tree level
10283 * Return <0 for error
10285 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10287 struct extent_buffer *eb;
10288 struct btrfs_path path;
10289 struct btrfs_key key;
10290 struct btrfs_extent_item *ei;
10293 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10298 /* Search extent tree for extent generation and level */
10299 key.objectid = bytenr;
10300 key.type = BTRFS_METADATA_ITEM_KEY;
10301 key.offset = (u64)-1;
10303 btrfs_init_path(&path);
10304 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10307 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10315 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10316 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10317 struct btrfs_extent_item);
10318 flags = btrfs_extent_flags(path.nodes[0], ei);
10319 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10324 /* Get transid for later read_tree_block() check */
10325 transid = btrfs_extent_generation(path.nodes[0], ei);
10327 /* Get backref level as one source */
10328 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10329 backref_level = key.offset;
10331 struct btrfs_tree_block_info *info;
10333 info = (struct btrfs_tree_block_info *)(ei + 1);
10334 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10336 btrfs_release_path(&path);
10338 /* Get level from tree block as an alternative source */
10339 eb = read_tree_block_fs_info(fs_info, bytenr, nodesize, transid);
10340 if (!extent_buffer_uptodate(eb)) {
10341 free_extent_buffer(eb);
10344 header_level = btrfs_header_level(eb);
10345 free_extent_buffer(eb);
10347 if (header_level != backref_level)
10349 return header_level;
10352 btrfs_release_path(&path);
10357 * Check if a tree block backref is valid (points to a valid tree block)
10358 * if level == -1, level will be resolved
10359 * Return >0 for any error found and print error message
10361 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10362 u64 bytenr, int level)
10364 struct btrfs_root *root;
10365 struct btrfs_key key;
10366 struct btrfs_path path;
10367 struct extent_buffer *eb;
10368 struct extent_buffer *node;
10369 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10373 /* Query level for level == -1 special case */
10375 level = query_tree_block_level(fs_info, bytenr);
10377 err |= REFERENCER_MISSING;
10381 key.objectid = root_id;
10382 key.type = BTRFS_ROOT_ITEM_KEY;
10383 key.offset = (u64)-1;
10385 root = btrfs_read_fs_root(fs_info, &key);
10386 if (IS_ERR(root)) {
10387 err |= REFERENCER_MISSING;
10391 /* Read out the tree block to get item/node key */
10392 eb = read_tree_block(root, bytenr, root->nodesize, 0);
10393 if (!extent_buffer_uptodate(eb)) {
10394 err |= REFERENCER_MISSING;
10395 free_extent_buffer(eb);
10399 /* Empty tree, no need to check key */
10400 if (!btrfs_header_nritems(eb) && !level) {
10401 free_extent_buffer(eb);
10406 btrfs_node_key_to_cpu(eb, &key, 0);
10408 btrfs_item_key_to_cpu(eb, &key, 0);
10410 free_extent_buffer(eb);
10412 btrfs_init_path(&path);
10413 path.lowest_level = level;
10414 /* Search with the first key, to ensure we can reach it */
10415 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10417 err |= REFERENCER_MISSING;
10421 node = path.nodes[level];
10422 if (btrfs_header_bytenr(node) != bytenr) {
10424 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10425 bytenr, nodesize, bytenr,
10426 btrfs_header_bytenr(node));
10427 err |= REFERENCER_MISMATCH;
10429 if (btrfs_header_level(node) != level) {
10431 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10432 bytenr, nodesize, level,
10433 btrfs_header_level(node));
10434 err |= REFERENCER_MISMATCH;
10438 btrfs_release_path(&path);
10440 if (err & REFERENCER_MISSING) {
10442 error("extent [%llu %d] lost referencer (owner: %llu)",
10443 bytenr, nodesize, root_id);
10446 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10447 bytenr, nodesize, root_id, level);
10454 * Check if tree block @eb is tree reloc root.
10455 * Return 0 if it's not or any problem happens
10456 * Return 1 if it's a tree reloc root
10458 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
10459 struct extent_buffer *eb)
10461 struct btrfs_root *tree_reloc_root;
10462 struct btrfs_key key;
10463 u64 bytenr = btrfs_header_bytenr(eb);
10464 u64 owner = btrfs_header_owner(eb);
10467 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
10468 key.offset = owner;
10469 key.type = BTRFS_ROOT_ITEM_KEY;
10471 tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
10472 if (IS_ERR(tree_reloc_root))
10475 if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
10477 btrfs_free_fs_root(tree_reloc_root);
10482 * Check referencer for shared block backref
10483 * If level == -1, this function will resolve the level.
10485 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10486 u64 parent, u64 bytenr, int level)
10488 struct extent_buffer *eb;
10489 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10491 int found_parent = 0;
10494 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10495 if (!extent_buffer_uptodate(eb))
10499 level = query_tree_block_level(fs_info, bytenr);
10503 /* It's possible it's a tree reloc root */
10504 if (parent == bytenr) {
10505 if (is_tree_reloc_root(fs_info, eb))
10510 if (level + 1 != btrfs_header_level(eb))
10513 nr = btrfs_header_nritems(eb);
10514 for (i = 0; i < nr; i++) {
10515 if (bytenr == btrfs_node_blockptr(eb, i)) {
10521 free_extent_buffer(eb);
10522 if (!found_parent) {
10524 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10525 bytenr, nodesize, parent, level);
10526 return REFERENCER_MISSING;
10532 * Check referencer for normal (inlined) data ref
10533 * If len == 0, it will be resolved by searching in extent tree
10535 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10536 u64 root_id, u64 objectid, u64 offset,
10537 u64 bytenr, u64 len, u32 count)
10539 struct btrfs_root *root;
10540 struct btrfs_root *extent_root = fs_info->extent_root;
10541 struct btrfs_key key;
10542 struct btrfs_path path;
10543 struct extent_buffer *leaf;
10544 struct btrfs_file_extent_item *fi;
10545 u32 found_count = 0;
10550 key.objectid = bytenr;
10551 key.type = BTRFS_EXTENT_ITEM_KEY;
10552 key.offset = (u64)-1;
10554 btrfs_init_path(&path);
10555 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10558 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10561 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10562 if (key.objectid != bytenr ||
10563 key.type != BTRFS_EXTENT_ITEM_KEY)
10566 btrfs_release_path(&path);
10568 key.objectid = root_id;
10569 key.type = BTRFS_ROOT_ITEM_KEY;
10570 key.offset = (u64)-1;
10571 btrfs_init_path(&path);
10573 root = btrfs_read_fs_root(fs_info, &key);
10577 key.objectid = objectid;
10578 key.type = BTRFS_EXTENT_DATA_KEY;
10580 * It can be nasty as data backref offset is
10581 * file offset - file extent offset, which is smaller or
10582 * equal to original backref offset. The only special case is
10583 * overflow. So we need to special check and do further search.
10585 key.offset = offset & (1ULL << 63) ? 0 : offset;
10587 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10592 * Search afterwards to get correct one
10593 * NOTE: As we must do a comprehensive check on the data backref to
10594 * make sure the dref count also matches, we must iterate all file
10595 * extents for that inode.
10598 leaf = path.nodes[0];
10599 slot = path.slots[0];
10601 if (slot >= btrfs_header_nritems(leaf))
10603 btrfs_item_key_to_cpu(leaf, &key, slot);
10604 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10606 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10608 * Except normal disk bytenr and disk num bytes, we still
10609 * need to do extra check on dbackref offset as
10610 * dbackref offset = file_offset - file_extent_offset
10612 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10613 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10614 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10619 ret = btrfs_next_item(root, &path);
10624 btrfs_release_path(&path);
10625 if (found_count != count) {
10627 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10628 bytenr, len, root_id, objectid, offset, count, found_count);
10629 return REFERENCER_MISSING;
10635 * Check if the referencer of a shared data backref exists
10637 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10638 u64 parent, u64 bytenr)
10640 struct extent_buffer *eb;
10641 struct btrfs_key key;
10642 struct btrfs_file_extent_item *fi;
10643 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10645 int found_parent = 0;
10648 eb = read_tree_block_fs_info(fs_info, parent, nodesize, 0);
10649 if (!extent_buffer_uptodate(eb))
10652 nr = btrfs_header_nritems(eb);
10653 for (i = 0; i < nr; i++) {
10654 btrfs_item_key_to_cpu(eb, &key, i);
10655 if (key.type != BTRFS_EXTENT_DATA_KEY)
10658 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10659 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10662 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10669 free_extent_buffer(eb);
10670 if (!found_parent) {
10671 error("shared extent %llu referencer lost (parent: %llu)",
10673 return REFERENCER_MISSING;
10679 * This function will check a given extent item, including its backref and
10680 * itself (like crossing stripe boundary and type)
10682 * Since we don't use extent_record anymore, introduce new error bit
10684 static int check_extent_item(struct btrfs_fs_info *fs_info,
10685 struct extent_buffer *eb, int slot)
10687 struct btrfs_extent_item *ei;
10688 struct btrfs_extent_inline_ref *iref;
10689 struct btrfs_extent_data_ref *dref;
10693 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10694 u32 item_size = btrfs_item_size_nr(eb, slot);
10699 struct btrfs_key key;
10703 btrfs_item_key_to_cpu(eb, &key, slot);
10704 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10705 bytes_used += key.offset;
10707 bytes_used += nodesize;
10709 if (item_size < sizeof(*ei)) {
10711 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10712 * old thing when on disk format is still un-determined.
10713 * No need to care about it anymore
10715 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10719 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10720 flags = btrfs_extent_flags(eb, ei);
10722 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10724 if (metadata && check_crossing_stripes(global_info, key.objectid,
10726 error("bad metadata [%llu, %llu) crossing stripe boundary",
10727 key.objectid, key.objectid + nodesize);
10728 err |= CROSSING_STRIPE_BOUNDARY;
10731 ptr = (unsigned long)(ei + 1);
10733 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10734 /* Old EXTENT_ITEM metadata */
10735 struct btrfs_tree_block_info *info;
10737 info = (struct btrfs_tree_block_info *)ptr;
10738 level = btrfs_tree_block_level(eb, info);
10739 ptr += sizeof(struct btrfs_tree_block_info);
10741 /* New METADATA_ITEM */
10742 level = key.offset;
10744 end = (unsigned long)ei + item_size;
10747 /* Reached extent item end normally */
10751 /* Beyond extent item end, wrong item size */
10753 err |= ITEM_SIZE_MISMATCH;
10754 error("extent item at bytenr %llu slot %d has wrong size",
10759 /* Now check every backref in this extent item */
10760 iref = (struct btrfs_extent_inline_ref *)ptr;
10761 type = btrfs_extent_inline_ref_type(eb, iref);
10762 offset = btrfs_extent_inline_ref_offset(eb, iref);
10764 case BTRFS_TREE_BLOCK_REF_KEY:
10765 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10769 case BTRFS_SHARED_BLOCK_REF_KEY:
10770 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10774 case BTRFS_EXTENT_DATA_REF_KEY:
10775 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10776 ret = check_extent_data_backref(fs_info,
10777 btrfs_extent_data_ref_root(eb, dref),
10778 btrfs_extent_data_ref_objectid(eb, dref),
10779 btrfs_extent_data_ref_offset(eb, dref),
10780 key.objectid, key.offset,
10781 btrfs_extent_data_ref_count(eb, dref));
10784 case BTRFS_SHARED_DATA_REF_KEY:
10785 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10789 error("extent[%llu %d %llu] has unknown ref type: %d",
10790 key.objectid, key.type, key.offset, type);
10791 err |= UNKNOWN_TYPE;
10795 ptr += btrfs_extent_inline_ref_size(type);
10803 * Check if a dev extent item is referred correctly by its chunk
10805 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10806 struct extent_buffer *eb, int slot)
10808 struct btrfs_root *chunk_root = fs_info->chunk_root;
10809 struct btrfs_dev_extent *ptr;
10810 struct btrfs_path path;
10811 struct btrfs_key chunk_key;
10812 struct btrfs_key devext_key;
10813 struct btrfs_chunk *chunk;
10814 struct extent_buffer *l;
10818 int found_chunk = 0;
10821 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10822 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10823 length = btrfs_dev_extent_length(eb, ptr);
10825 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10826 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10827 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10829 btrfs_init_path(&path);
10830 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10835 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10836 if (btrfs_chunk_length(l, chunk) != length)
10839 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10840 for (i = 0; i < num_stripes; i++) {
10841 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10842 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10844 if (devid == devext_key.objectid &&
10845 offset == devext_key.offset) {
10851 btrfs_release_path(&path);
10852 if (!found_chunk) {
10854 "device extent[%llu, %llu, %llu] did not find the related chunk",
10855 devext_key.objectid, devext_key.offset, length);
10856 return REFERENCER_MISSING;
10862 * Check if the used space is correct with the dev item
10864 static int check_dev_item(struct btrfs_fs_info *fs_info,
10865 struct extent_buffer *eb, int slot)
10867 struct btrfs_root *dev_root = fs_info->dev_root;
10868 struct btrfs_dev_item *dev_item;
10869 struct btrfs_path path;
10870 struct btrfs_key key;
10871 struct btrfs_dev_extent *ptr;
10877 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10878 dev_id = btrfs_device_id(eb, dev_item);
10879 used = btrfs_device_bytes_used(eb, dev_item);
10881 key.objectid = dev_id;
10882 key.type = BTRFS_DEV_EXTENT_KEY;
10885 btrfs_init_path(&path);
10886 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
10888 btrfs_item_key_to_cpu(eb, &key, slot);
10889 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
10890 key.objectid, key.type, key.offset);
10891 btrfs_release_path(&path);
10892 return REFERENCER_MISSING;
10895 /* Iterate dev_extents to calculate the used space of a device */
10897 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
10900 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10901 if (key.objectid > dev_id)
10903 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
10906 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
10907 struct btrfs_dev_extent);
10908 total += btrfs_dev_extent_length(path.nodes[0], ptr);
10910 ret = btrfs_next_item(dev_root, &path);
10914 btrfs_release_path(&path);
10916 if (used != total) {
10917 btrfs_item_key_to_cpu(eb, &key, slot);
10919 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
10920 total, used, BTRFS_ROOT_TREE_OBJECTID,
10921 BTRFS_DEV_EXTENT_KEY, dev_id);
10922 return ACCOUNTING_MISMATCH;
10928 * Check a block group item with its referener (chunk) and its used space
10929 * with extent/metadata item
10931 static int check_block_group_item(struct btrfs_fs_info *fs_info,
10932 struct extent_buffer *eb, int slot)
10934 struct btrfs_root *extent_root = fs_info->extent_root;
10935 struct btrfs_root *chunk_root = fs_info->chunk_root;
10936 struct btrfs_block_group_item *bi;
10937 struct btrfs_block_group_item bg_item;
10938 struct btrfs_path path;
10939 struct btrfs_key bg_key;
10940 struct btrfs_key chunk_key;
10941 struct btrfs_key extent_key;
10942 struct btrfs_chunk *chunk;
10943 struct extent_buffer *leaf;
10944 struct btrfs_extent_item *ei;
10945 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10953 btrfs_item_key_to_cpu(eb, &bg_key, slot);
10954 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
10955 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
10956 used = btrfs_block_group_used(&bg_item);
10957 bg_flags = btrfs_block_group_flags(&bg_item);
10959 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
10960 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10961 chunk_key.offset = bg_key.objectid;
10963 btrfs_init_path(&path);
10964 /* Search for the referencer chunk */
10965 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10968 "block group[%llu %llu] did not find the related chunk item",
10969 bg_key.objectid, bg_key.offset);
10970 err |= REFERENCER_MISSING;
10972 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
10973 struct btrfs_chunk);
10974 if (btrfs_chunk_length(path.nodes[0], chunk) !=
10977 "block group[%llu %llu] related chunk item length does not match",
10978 bg_key.objectid, bg_key.offset);
10979 err |= REFERENCER_MISMATCH;
10982 btrfs_release_path(&path);
10984 /* Search from the block group bytenr */
10985 extent_key.objectid = bg_key.objectid;
10986 extent_key.type = 0;
10987 extent_key.offset = 0;
10989 btrfs_init_path(&path);
10990 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
10994 /* Iterate extent tree to account used space */
10996 leaf = path.nodes[0];
10998 /* Search slot can point to the last item beyond leaf nritems */
10999 if (path.slots[0] >= btrfs_header_nritems(leaf))
11002 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
11003 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
11006 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
11007 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
11009 if (extent_key.objectid < bg_key.objectid)
11012 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
11015 total += extent_key.offset;
11017 ei = btrfs_item_ptr(leaf, path.slots[0],
11018 struct btrfs_extent_item);
11019 flags = btrfs_extent_flags(leaf, ei);
11020 if (flags & BTRFS_EXTENT_FLAG_DATA) {
11021 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
11023 "bad extent[%llu, %llu) type mismatch with chunk",
11024 extent_key.objectid,
11025 extent_key.objectid + extent_key.offset);
11026 err |= CHUNK_TYPE_MISMATCH;
11028 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
11029 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
11030 BTRFS_BLOCK_GROUP_METADATA))) {
11032 "bad extent[%llu, %llu) type mismatch with chunk",
11033 extent_key.objectid,
11034 extent_key.objectid + nodesize);
11035 err |= CHUNK_TYPE_MISMATCH;
11039 ret = btrfs_next_item(extent_root, &path);
11045 btrfs_release_path(&path);
11047 if (total != used) {
11049 "block group[%llu %llu] used %llu but extent items used %llu",
11050 bg_key.objectid, bg_key.offset, used, total);
11051 err |= ACCOUNTING_MISMATCH;
11057 * Check a chunk item.
11058 * Including checking all referred dev_extents and block group
11060 static int check_chunk_item(struct btrfs_fs_info *fs_info,
11061 struct extent_buffer *eb, int slot)
11063 struct btrfs_root *extent_root = fs_info->extent_root;
11064 struct btrfs_root *dev_root = fs_info->dev_root;
11065 struct btrfs_path path;
11066 struct btrfs_key chunk_key;
11067 struct btrfs_key bg_key;
11068 struct btrfs_key devext_key;
11069 struct btrfs_chunk *chunk;
11070 struct extent_buffer *leaf;
11071 struct btrfs_block_group_item *bi;
11072 struct btrfs_block_group_item bg_item;
11073 struct btrfs_dev_extent *ptr;
11074 u32 sectorsize = btrfs_super_sectorsize(fs_info->super_copy);
11086 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11087 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11088 length = btrfs_chunk_length(eb, chunk);
11089 chunk_end = chunk_key.offset + length;
11090 if (!IS_ALIGNED(length, sectorsize)) {
11091 error("chunk[%llu %llu) not aligned to %u",
11092 chunk_key.offset, chunk_end, sectorsize);
11093 err |= BYTES_UNALIGNED;
11097 type = btrfs_chunk_type(eb, chunk);
11098 profile = type & BTRFS_BLOCK_GROUP_PROFILE_MASK;
11099 if (!(type & BTRFS_BLOCK_GROUP_TYPE_MASK)) {
11100 error("chunk[%llu %llu) has no chunk type",
11101 chunk_key.offset, chunk_end);
11102 err |= UNKNOWN_TYPE;
11104 if (profile && (profile & (profile - 1))) {
11105 error("chunk[%llu %llu) multiple profiles detected: %llx",
11106 chunk_key.offset, chunk_end, profile);
11107 err |= UNKNOWN_TYPE;
11110 bg_key.objectid = chunk_key.offset;
11111 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11112 bg_key.offset = length;
11114 btrfs_init_path(&path);
11115 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11118 "chunk[%llu %llu) did not find the related block group item",
11119 chunk_key.offset, chunk_end);
11120 err |= REFERENCER_MISSING;
11122 leaf = path.nodes[0];
11123 bi = btrfs_item_ptr(leaf, path.slots[0],
11124 struct btrfs_block_group_item);
11125 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11127 if (btrfs_block_group_flags(&bg_item) != type) {
11129 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11130 chunk_key.offset, chunk_end, type,
11131 btrfs_block_group_flags(&bg_item));
11132 err |= REFERENCER_MISSING;
11136 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11137 for (i = 0; i < num_stripes; i++) {
11138 btrfs_release_path(&path);
11139 btrfs_init_path(&path);
11140 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11141 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11142 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11144 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11147 goto not_match_dev;
11149 leaf = path.nodes[0];
11150 ptr = btrfs_item_ptr(leaf, path.slots[0],
11151 struct btrfs_dev_extent);
11152 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11153 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11154 if (objectid != chunk_key.objectid ||
11155 offset != chunk_key.offset ||
11156 btrfs_dev_extent_length(leaf, ptr) != length)
11157 goto not_match_dev;
11160 err |= BACKREF_MISSING;
11162 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11163 chunk_key.objectid, chunk_end, i);
11166 btrfs_release_path(&path);
11172 * Main entry function to check known items and update related accounting info
11174 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11176 struct btrfs_fs_info *fs_info = root->fs_info;
11177 struct btrfs_key key;
11180 struct btrfs_extent_data_ref *dref;
11185 btrfs_item_key_to_cpu(eb, &key, slot);
11189 case BTRFS_EXTENT_DATA_KEY:
11190 ret = check_extent_data_item(root, eb, slot);
11193 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11194 ret = check_block_group_item(fs_info, eb, slot);
11197 case BTRFS_DEV_ITEM_KEY:
11198 ret = check_dev_item(fs_info, eb, slot);
11201 case BTRFS_CHUNK_ITEM_KEY:
11202 ret = check_chunk_item(fs_info, eb, slot);
11205 case BTRFS_DEV_EXTENT_KEY:
11206 ret = check_dev_extent_item(fs_info, eb, slot);
11209 case BTRFS_EXTENT_ITEM_KEY:
11210 case BTRFS_METADATA_ITEM_KEY:
11211 ret = check_extent_item(fs_info, eb, slot);
11214 case BTRFS_EXTENT_CSUM_KEY:
11215 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11217 case BTRFS_TREE_BLOCK_REF_KEY:
11218 ret = check_tree_block_backref(fs_info, key.offset,
11222 case BTRFS_EXTENT_DATA_REF_KEY:
11223 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11224 ret = check_extent_data_backref(fs_info,
11225 btrfs_extent_data_ref_root(eb, dref),
11226 btrfs_extent_data_ref_objectid(eb, dref),
11227 btrfs_extent_data_ref_offset(eb, dref),
11229 btrfs_extent_data_ref_count(eb, dref));
11232 case BTRFS_SHARED_BLOCK_REF_KEY:
11233 ret = check_shared_block_backref(fs_info, key.offset,
11237 case BTRFS_SHARED_DATA_REF_KEY:
11238 ret = check_shared_data_backref(fs_info, key.offset,
11246 if (++slot < btrfs_header_nritems(eb))
11253 * Helper function for later fs/subvol tree check. To determine if a tree
11254 * block should be checked.
11255 * This function will ensure only the direct referencer with lowest rootid to
11256 * check a fs/subvolume tree block.
11258 * Backref check at extent tree would detect errors like missing subvolume
11259 * tree, so we can do aggressive check to reduce duplicated checks.
11261 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11263 struct btrfs_root *extent_root = root->fs_info->extent_root;
11264 struct btrfs_key key;
11265 struct btrfs_path path;
11266 struct extent_buffer *leaf;
11268 struct btrfs_extent_item *ei;
11274 struct btrfs_extent_inline_ref *iref;
11277 btrfs_init_path(&path);
11278 key.objectid = btrfs_header_bytenr(eb);
11279 key.type = BTRFS_METADATA_ITEM_KEY;
11280 key.offset = (u64)-1;
11283 * Any failure in backref resolving means we can't determine
11284 * whom the tree block belongs to.
11285 * So in that case, we need to check that tree block
11287 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11291 ret = btrfs_previous_extent_item(extent_root, &path,
11292 btrfs_header_bytenr(eb));
11296 leaf = path.nodes[0];
11297 slot = path.slots[0];
11298 btrfs_item_key_to_cpu(leaf, &key, slot);
11299 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11301 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11302 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11304 struct btrfs_tree_block_info *info;
11306 info = (struct btrfs_tree_block_info *)(ei + 1);
11307 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11310 item_size = btrfs_item_size_nr(leaf, slot);
11311 ptr = (unsigned long)iref;
11312 end = (unsigned long)ei + item_size;
11313 while (ptr < end) {
11314 iref = (struct btrfs_extent_inline_ref *)ptr;
11315 type = btrfs_extent_inline_ref_type(leaf, iref);
11316 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11319 * We only check the tree block if current root is
11320 * the lowest referencer of it.
11322 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11323 offset < root->objectid) {
11324 btrfs_release_path(&path);
11328 ptr += btrfs_extent_inline_ref_size(type);
11331 * Normally we should also check keyed tree block ref, but that may be
11332 * very time consuming. Inlined ref should already make us skip a lot
11333 * of refs now. So skip search keyed tree block ref.
11337 btrfs_release_path(&path);
11342 * Traversal function for tree block. We will do:
11343 * 1) Skip shared fs/subvolume tree blocks
11344 * 2) Update related bytes accounting
11345 * 3) Pre-order traversal
11347 static int traverse_tree_block(struct btrfs_root *root,
11348 struct extent_buffer *node)
11350 struct extent_buffer *eb;
11351 struct btrfs_key key;
11352 struct btrfs_key drop_key;
11360 * Skip shared fs/subvolume tree block, in that case they will
11361 * be checked by referencer with lowest rootid
11363 if (is_fstree(root->objectid) && !should_check(root, node))
11366 /* Update bytes accounting */
11367 total_btree_bytes += node->len;
11368 if (fs_root_objectid(btrfs_header_owner(node)))
11369 total_fs_tree_bytes += node->len;
11370 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11371 total_extent_tree_bytes += node->len;
11372 if (!found_old_backref &&
11373 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11374 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11375 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11376 found_old_backref = 1;
11378 /* pre-order tranversal, check itself first */
11379 level = btrfs_header_level(node);
11380 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11381 btrfs_header_level(node),
11382 btrfs_header_owner(node));
11386 "check %s failed root %llu bytenr %llu level %d, force continue check",
11387 level ? "node":"leaf", root->objectid,
11388 btrfs_header_bytenr(node), btrfs_header_level(node));
11391 btree_space_waste += btrfs_leaf_free_space(root, node);
11392 ret = check_leaf_items(root, node);
11397 nr = btrfs_header_nritems(node);
11398 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11399 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11400 sizeof(struct btrfs_key_ptr);
11402 /* Then check all its children */
11403 for (i = 0; i < nr; i++) {
11404 u64 blocknr = btrfs_node_blockptr(node, i);
11406 btrfs_node_key_to_cpu(node, &key, i);
11407 if (level == root->root_item.drop_level &&
11408 is_dropped_key(&key, &drop_key))
11412 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11413 * to call the function itself.
11415 eb = read_tree_block(root, blocknr, root->nodesize, 0);
11416 if (extent_buffer_uptodate(eb)) {
11417 ret = traverse_tree_block(root, eb);
11420 free_extent_buffer(eb);
11427 * Low memory usage version check_chunks_and_extents.
11429 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11431 struct btrfs_path path;
11432 struct btrfs_key key;
11433 struct btrfs_root *root1;
11434 struct btrfs_root *cur_root;
11438 root1 = root->fs_info->chunk_root;
11439 ret = traverse_tree_block(root1, root1->node);
11442 root1 = root->fs_info->tree_root;
11443 ret = traverse_tree_block(root1, root1->node);
11446 btrfs_init_path(&path);
11447 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11449 key.type = BTRFS_ROOT_ITEM_KEY;
11451 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11453 error("cannot find extent treet in tree_root");
11458 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11459 if (key.type != BTRFS_ROOT_ITEM_KEY)
11461 key.offset = (u64)-1;
11463 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11464 cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
11467 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11468 if (IS_ERR(cur_root) || !cur_root) {
11469 error("failed to read tree: %lld", key.objectid);
11473 ret = traverse_tree_block(cur_root, cur_root->node);
11476 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11477 btrfs_free_fs_root(cur_root);
11479 ret = btrfs_next_item(root1, &path);
11485 btrfs_release_path(&path);
11489 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11490 struct btrfs_root *root, int overwrite)
11492 struct extent_buffer *c;
11493 struct extent_buffer *old = root->node;
11496 struct btrfs_disk_key disk_key = {0,0,0};
11502 extent_buffer_get(c);
11505 c = btrfs_alloc_free_block(trans, root,
11507 root->root_key.objectid,
11508 &disk_key, level, 0, 0);
11511 extent_buffer_get(c);
11515 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11516 btrfs_set_header_level(c, level);
11517 btrfs_set_header_bytenr(c, c->start);
11518 btrfs_set_header_generation(c, trans->transid);
11519 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11520 btrfs_set_header_owner(c, root->root_key.objectid);
11522 write_extent_buffer(c, root->fs_info->fsid,
11523 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11525 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11526 btrfs_header_chunk_tree_uuid(c),
11529 btrfs_mark_buffer_dirty(c);
11531 * this case can happen in the following case:
11533 * 1.overwrite previous root.
11535 * 2.reinit reloc data root, this is because we skip pin
11536 * down reloc data tree before which means we can allocate
11537 * same block bytenr here.
11539 if (old->start == c->start) {
11540 btrfs_set_root_generation(&root->root_item,
11542 root->root_item.level = btrfs_header_level(root->node);
11543 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11544 &root->root_key, &root->root_item);
11546 free_extent_buffer(c);
11550 free_extent_buffer(old);
11552 add_root_to_dirty_list(root);
11556 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11557 struct extent_buffer *eb, int tree_root)
11559 struct extent_buffer *tmp;
11560 struct btrfs_root_item *ri;
11561 struct btrfs_key key;
11564 int level = btrfs_header_level(eb);
11570 * If we have pinned this block before, don't pin it again.
11571 * This can not only avoid forever loop with broken filesystem
11572 * but also give us some speedups.
11574 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11575 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11578 btrfs_pin_extent(fs_info, eb->start, eb->len);
11580 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11581 nritems = btrfs_header_nritems(eb);
11582 for (i = 0; i < nritems; i++) {
11584 btrfs_item_key_to_cpu(eb, &key, i);
11585 if (key.type != BTRFS_ROOT_ITEM_KEY)
11587 /* Skip the extent root and reloc roots */
11588 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11589 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11590 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11592 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11593 bytenr = btrfs_disk_root_bytenr(eb, ri);
11596 * If at any point we start needing the real root we
11597 * will have to build a stump root for the root we are
11598 * in, but for now this doesn't actually use the root so
11599 * just pass in extent_root.
11601 tmp = read_tree_block(fs_info->extent_root, bytenr,
11603 if (!extent_buffer_uptodate(tmp)) {
11604 fprintf(stderr, "Error reading root block\n");
11607 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11608 free_extent_buffer(tmp);
11612 bytenr = btrfs_node_blockptr(eb, i);
11614 /* If we aren't the tree root don't read the block */
11615 if (level == 1 && !tree_root) {
11616 btrfs_pin_extent(fs_info, bytenr, nodesize);
11620 tmp = read_tree_block(fs_info->extent_root, bytenr,
11622 if (!extent_buffer_uptodate(tmp)) {
11623 fprintf(stderr, "Error reading tree block\n");
11626 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11627 free_extent_buffer(tmp);
11636 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11640 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11644 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11647 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11649 struct btrfs_block_group_cache *cache;
11650 struct btrfs_path path;
11651 struct extent_buffer *leaf;
11652 struct btrfs_chunk *chunk;
11653 struct btrfs_key key;
11657 btrfs_init_path(&path);
11659 key.type = BTRFS_CHUNK_ITEM_KEY;
11661 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11663 btrfs_release_path(&path);
11668 * We do this in case the block groups were screwed up and had alloc
11669 * bits that aren't actually set on the chunks. This happens with
11670 * restored images every time and could happen in real life I guess.
11672 fs_info->avail_data_alloc_bits = 0;
11673 fs_info->avail_metadata_alloc_bits = 0;
11674 fs_info->avail_system_alloc_bits = 0;
11676 /* First we need to create the in-memory block groups */
11678 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11679 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11681 btrfs_release_path(&path);
11689 leaf = path.nodes[0];
11690 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11691 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11696 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11697 btrfs_add_block_group(fs_info, 0,
11698 btrfs_chunk_type(leaf, chunk),
11699 key.objectid, key.offset,
11700 btrfs_chunk_length(leaf, chunk));
11701 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11702 key.offset + btrfs_chunk_length(leaf, chunk));
11707 cache = btrfs_lookup_first_block_group(fs_info, start);
11711 start = cache->key.objectid + cache->key.offset;
11714 btrfs_release_path(&path);
11718 static int reset_balance(struct btrfs_trans_handle *trans,
11719 struct btrfs_fs_info *fs_info)
11721 struct btrfs_root *root = fs_info->tree_root;
11722 struct btrfs_path path;
11723 struct extent_buffer *leaf;
11724 struct btrfs_key key;
11725 int del_slot, del_nr = 0;
11729 btrfs_init_path(&path);
11730 key.objectid = BTRFS_BALANCE_OBJECTID;
11731 key.type = BTRFS_BALANCE_ITEM_KEY;
11733 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11738 goto reinit_data_reloc;
11743 ret = btrfs_del_item(trans, root, &path);
11746 btrfs_release_path(&path);
11748 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11749 key.type = BTRFS_ROOT_ITEM_KEY;
11751 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11755 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11760 ret = btrfs_del_items(trans, root, &path,
11767 btrfs_release_path(&path);
11770 ret = btrfs_search_slot(trans, root, &key, &path,
11777 leaf = path.nodes[0];
11778 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11779 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11781 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11786 del_slot = path.slots[0];
11795 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11799 btrfs_release_path(&path);
11802 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11803 key.type = BTRFS_ROOT_ITEM_KEY;
11804 key.offset = (u64)-1;
11805 root = btrfs_read_fs_root(fs_info, &key);
11806 if (IS_ERR(root)) {
11807 fprintf(stderr, "Error reading data reloc tree\n");
11808 ret = PTR_ERR(root);
11811 record_root_in_trans(trans, root);
11812 ret = btrfs_fsck_reinit_root(trans, root, 0);
11815 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11817 btrfs_release_path(&path);
11821 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11822 struct btrfs_fs_info *fs_info)
11828 * The only reason we don't do this is because right now we're just
11829 * walking the trees we find and pinning down their bytes, we don't look
11830 * at any of the leaves. In order to do mixed groups we'd have to check
11831 * the leaves of any fs roots and pin down the bytes for any file
11832 * extents we find. Not hard but why do it if we don't have to?
11834 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11835 fprintf(stderr, "We don't support re-initing the extent tree "
11836 "for mixed block groups yet, please notify a btrfs "
11837 "developer you want to do this so they can add this "
11838 "functionality.\n");
11843 * first we need to walk all of the trees except the extent tree and pin
11844 * down the bytes that are in use so we don't overwrite any existing
11847 ret = pin_metadata_blocks(fs_info);
11849 fprintf(stderr, "error pinning down used bytes\n");
11854 * Need to drop all the block groups since we're going to recreate all
11857 btrfs_free_block_groups(fs_info);
11858 ret = reset_block_groups(fs_info);
11860 fprintf(stderr, "error resetting the block groups\n");
11864 /* Ok we can allocate now, reinit the extent root */
11865 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11867 fprintf(stderr, "extent root initialization failed\n");
11869 * When the transaction code is updated we should end the
11870 * transaction, but for now progs only knows about commit so
11871 * just return an error.
11877 * Now we have all the in-memory block groups setup so we can make
11878 * allocations properly, and the metadata we care about is safe since we
11879 * pinned all of it above.
11882 struct btrfs_block_group_cache *cache;
11884 cache = btrfs_lookup_first_block_group(fs_info, start);
11887 start = cache->key.objectid + cache->key.offset;
11888 ret = btrfs_insert_item(trans, fs_info->extent_root,
11889 &cache->key, &cache->item,
11890 sizeof(cache->item));
11892 fprintf(stderr, "Error adding block group\n");
11895 btrfs_extent_post_op(trans, fs_info->extent_root);
11898 ret = reset_balance(trans, fs_info);
11900 fprintf(stderr, "error resetting the pending balance\n");
11905 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
11907 struct btrfs_path path;
11908 struct btrfs_trans_handle *trans;
11909 struct btrfs_key key;
11912 printf("Recowing metadata block %llu\n", eb->start);
11913 key.objectid = btrfs_header_owner(eb);
11914 key.type = BTRFS_ROOT_ITEM_KEY;
11915 key.offset = (u64)-1;
11917 root = btrfs_read_fs_root(root->fs_info, &key);
11918 if (IS_ERR(root)) {
11919 fprintf(stderr, "Couldn't find owner root %llu\n",
11921 return PTR_ERR(root);
11924 trans = btrfs_start_transaction(root, 1);
11926 return PTR_ERR(trans);
11928 btrfs_init_path(&path);
11929 path.lowest_level = btrfs_header_level(eb);
11930 if (path.lowest_level)
11931 btrfs_node_key_to_cpu(eb, &key, 0);
11933 btrfs_item_key_to_cpu(eb, &key, 0);
11935 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
11936 btrfs_commit_transaction(trans, root);
11937 btrfs_release_path(&path);
11941 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
11943 struct btrfs_path path;
11944 struct btrfs_trans_handle *trans;
11945 struct btrfs_key key;
11948 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
11949 bad->key.type, bad->key.offset);
11950 key.objectid = bad->root_id;
11951 key.type = BTRFS_ROOT_ITEM_KEY;
11952 key.offset = (u64)-1;
11954 root = btrfs_read_fs_root(root->fs_info, &key);
11955 if (IS_ERR(root)) {
11956 fprintf(stderr, "Couldn't find owner root %llu\n",
11958 return PTR_ERR(root);
11961 trans = btrfs_start_transaction(root, 1);
11963 return PTR_ERR(trans);
11965 btrfs_init_path(&path);
11966 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
11972 ret = btrfs_del_item(trans, root, &path);
11974 btrfs_commit_transaction(trans, root);
11975 btrfs_release_path(&path);
11979 static int zero_log_tree(struct btrfs_root *root)
11981 struct btrfs_trans_handle *trans;
11984 trans = btrfs_start_transaction(root, 1);
11985 if (IS_ERR(trans)) {
11986 ret = PTR_ERR(trans);
11989 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
11990 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
11991 ret = btrfs_commit_transaction(trans, root);
11995 static int populate_csum(struct btrfs_trans_handle *trans,
11996 struct btrfs_root *csum_root, char *buf, u64 start,
12003 while (offset < len) {
12004 sectorsize = csum_root->sectorsize;
12005 ret = read_extent_data(csum_root, buf, start + offset,
12009 ret = btrfs_csum_file_block(trans, csum_root, start + len,
12010 start + offset, buf, sectorsize);
12013 offset += sectorsize;
12018 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
12019 struct btrfs_root *csum_root,
12020 struct btrfs_root *cur_root)
12022 struct btrfs_path path;
12023 struct btrfs_key key;
12024 struct extent_buffer *node;
12025 struct btrfs_file_extent_item *fi;
12032 buf = malloc(cur_root->fs_info->csum_root->sectorsize);
12036 btrfs_init_path(&path);
12040 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
12043 /* Iterate all regular file extents and fill its csum */
12045 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12047 if (key.type != BTRFS_EXTENT_DATA_KEY)
12049 node = path.nodes[0];
12050 slot = path.slots[0];
12051 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
12052 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
12054 start = btrfs_file_extent_disk_bytenr(node, fi);
12055 len = btrfs_file_extent_disk_num_bytes(node, fi);
12057 ret = populate_csum(trans, csum_root, buf, start, len);
12058 if (ret == -EEXIST)
12064 * TODO: if next leaf is corrupted, jump to nearest next valid
12067 ret = btrfs_next_item(cur_root, &path);
12077 btrfs_release_path(&path);
12082 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12083 struct btrfs_root *csum_root)
12085 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12086 struct btrfs_path path;
12087 struct btrfs_root *tree_root = fs_info->tree_root;
12088 struct btrfs_root *cur_root;
12089 struct extent_buffer *node;
12090 struct btrfs_key key;
12094 btrfs_init_path(&path);
12095 key.objectid = BTRFS_FS_TREE_OBJECTID;
12097 key.type = BTRFS_ROOT_ITEM_KEY;
12098 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12107 node = path.nodes[0];
12108 slot = path.slots[0];
12109 btrfs_item_key_to_cpu(node, &key, slot);
12110 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12112 if (key.type != BTRFS_ROOT_ITEM_KEY)
12114 if (!is_fstree(key.objectid))
12116 key.offset = (u64)-1;
12118 cur_root = btrfs_read_fs_root(fs_info, &key);
12119 if (IS_ERR(cur_root) || !cur_root) {
12120 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12124 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12129 ret = btrfs_next_item(tree_root, &path);
12139 btrfs_release_path(&path);
12143 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12144 struct btrfs_root *csum_root)
12146 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12147 struct btrfs_path path;
12148 struct btrfs_extent_item *ei;
12149 struct extent_buffer *leaf;
12151 struct btrfs_key key;
12154 btrfs_init_path(&path);
12156 key.type = BTRFS_EXTENT_ITEM_KEY;
12158 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12160 btrfs_release_path(&path);
12164 buf = malloc(csum_root->sectorsize);
12166 btrfs_release_path(&path);
12171 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12172 ret = btrfs_next_leaf(extent_root, &path);
12180 leaf = path.nodes[0];
12182 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12183 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12188 ei = btrfs_item_ptr(leaf, path.slots[0],
12189 struct btrfs_extent_item);
12190 if (!(btrfs_extent_flags(leaf, ei) &
12191 BTRFS_EXTENT_FLAG_DATA)) {
12196 ret = populate_csum(trans, csum_root, buf, key.objectid,
12203 btrfs_release_path(&path);
12209 * Recalculate the csum and put it into the csum tree.
12211 * Extent tree init will wipe out all the extent info, so in that case, we
12212 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12213 * will use fs/subvol trees to init the csum tree.
12215 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12216 struct btrfs_root *csum_root,
12217 int search_fs_tree)
12219 if (search_fs_tree)
12220 return fill_csum_tree_from_fs(trans, csum_root);
12222 return fill_csum_tree_from_extent(trans, csum_root);
12225 static void free_roots_info_cache(void)
12227 if (!roots_info_cache)
12230 while (!cache_tree_empty(roots_info_cache)) {
12231 struct cache_extent *entry;
12232 struct root_item_info *rii;
12234 entry = first_cache_extent(roots_info_cache);
12237 remove_cache_extent(roots_info_cache, entry);
12238 rii = container_of(entry, struct root_item_info, cache_extent);
12242 free(roots_info_cache);
12243 roots_info_cache = NULL;
12246 static int build_roots_info_cache(struct btrfs_fs_info *info)
12249 struct btrfs_key key;
12250 struct extent_buffer *leaf;
12251 struct btrfs_path path;
12253 if (!roots_info_cache) {
12254 roots_info_cache = malloc(sizeof(*roots_info_cache));
12255 if (!roots_info_cache)
12257 cache_tree_init(roots_info_cache);
12260 btrfs_init_path(&path);
12262 key.type = BTRFS_EXTENT_ITEM_KEY;
12264 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12267 leaf = path.nodes[0];
12270 struct btrfs_key found_key;
12271 struct btrfs_extent_item *ei;
12272 struct btrfs_extent_inline_ref *iref;
12273 int slot = path.slots[0];
12278 struct cache_extent *entry;
12279 struct root_item_info *rii;
12281 if (slot >= btrfs_header_nritems(leaf)) {
12282 ret = btrfs_next_leaf(info->extent_root, &path);
12289 leaf = path.nodes[0];
12290 slot = path.slots[0];
12293 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12295 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12296 found_key.type != BTRFS_METADATA_ITEM_KEY)
12299 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12300 flags = btrfs_extent_flags(leaf, ei);
12302 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12303 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12306 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12307 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12308 level = found_key.offset;
12310 struct btrfs_tree_block_info *binfo;
12312 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12313 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12314 level = btrfs_tree_block_level(leaf, binfo);
12318 * For a root extent, it must be of the following type and the
12319 * first (and only one) iref in the item.
12321 type = btrfs_extent_inline_ref_type(leaf, iref);
12322 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12325 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12326 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12328 rii = malloc(sizeof(struct root_item_info));
12333 rii->cache_extent.start = root_id;
12334 rii->cache_extent.size = 1;
12335 rii->level = (u8)-1;
12336 entry = &rii->cache_extent;
12337 ret = insert_cache_extent(roots_info_cache, entry);
12340 rii = container_of(entry, struct root_item_info,
12344 ASSERT(rii->cache_extent.start == root_id);
12345 ASSERT(rii->cache_extent.size == 1);
12347 if (level > rii->level || rii->level == (u8)-1) {
12348 rii->level = level;
12349 rii->bytenr = found_key.objectid;
12350 rii->gen = btrfs_extent_generation(leaf, ei);
12351 rii->node_count = 1;
12352 } else if (level == rii->level) {
12360 btrfs_release_path(&path);
12365 static int maybe_repair_root_item(struct btrfs_path *path,
12366 const struct btrfs_key *root_key,
12367 const int read_only_mode)
12369 const u64 root_id = root_key->objectid;
12370 struct cache_extent *entry;
12371 struct root_item_info *rii;
12372 struct btrfs_root_item ri;
12373 unsigned long offset;
12375 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12378 "Error: could not find extent items for root %llu\n",
12379 root_key->objectid);
12383 rii = container_of(entry, struct root_item_info, cache_extent);
12384 ASSERT(rii->cache_extent.start == root_id);
12385 ASSERT(rii->cache_extent.size == 1);
12387 if (rii->node_count != 1) {
12389 "Error: could not find btree root extent for root %llu\n",
12394 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12395 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12397 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12398 btrfs_root_level(&ri) != rii->level ||
12399 btrfs_root_generation(&ri) != rii->gen) {
12402 * If we're in repair mode but our caller told us to not update
12403 * the root item, i.e. just check if it needs to be updated, don't
12404 * print this message, since the caller will call us again shortly
12405 * for the same root item without read only mode (the caller will
12406 * open a transaction first).
12408 if (!(read_only_mode && repair))
12410 "%sroot item for root %llu,"
12411 " current bytenr %llu, current gen %llu, current level %u,"
12412 " new bytenr %llu, new gen %llu, new level %u\n",
12413 (read_only_mode ? "" : "fixing "),
12415 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12416 btrfs_root_level(&ri),
12417 rii->bytenr, rii->gen, rii->level);
12419 if (btrfs_root_generation(&ri) > rii->gen) {
12421 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12422 root_id, btrfs_root_generation(&ri), rii->gen);
12426 if (!read_only_mode) {
12427 btrfs_set_root_bytenr(&ri, rii->bytenr);
12428 btrfs_set_root_level(&ri, rii->level);
12429 btrfs_set_root_generation(&ri, rii->gen);
12430 write_extent_buffer(path->nodes[0], &ri,
12431 offset, sizeof(ri));
12441 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12442 * caused read-only snapshots to be corrupted if they were created at a moment
12443 * when the source subvolume/snapshot had orphan items. The issue was that the
12444 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12445 * node instead of the post orphan cleanup root node.
12446 * So this function, and its callees, just detects and fixes those cases. Even
12447 * though the regression was for read-only snapshots, this function applies to
12448 * any snapshot/subvolume root.
12449 * This must be run before any other repair code - not doing it so, makes other
12450 * repair code delete or modify backrefs in the extent tree for example, which
12451 * will result in an inconsistent fs after repairing the root items.
12453 static int repair_root_items(struct btrfs_fs_info *info)
12455 struct btrfs_path path;
12456 struct btrfs_key key;
12457 struct extent_buffer *leaf;
12458 struct btrfs_trans_handle *trans = NULL;
12461 int need_trans = 0;
12463 btrfs_init_path(&path);
12465 ret = build_roots_info_cache(info);
12469 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12470 key.type = BTRFS_ROOT_ITEM_KEY;
12475 * Avoid opening and committing transactions if a leaf doesn't have
12476 * any root items that need to be fixed, so that we avoid rotating
12477 * backup roots unnecessarily.
12480 trans = btrfs_start_transaction(info->tree_root, 1);
12481 if (IS_ERR(trans)) {
12482 ret = PTR_ERR(trans);
12487 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12491 leaf = path.nodes[0];
12494 struct btrfs_key found_key;
12496 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12497 int no_more_keys = find_next_key(&path, &key);
12499 btrfs_release_path(&path);
12501 ret = btrfs_commit_transaction(trans,
12513 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12515 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12517 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12520 ret = maybe_repair_root_item(&path, &found_key, trans ? 0 : 1);
12524 if (!trans && repair) {
12527 btrfs_release_path(&path);
12537 free_roots_info_cache();
12538 btrfs_release_path(&path);
12540 btrfs_commit_transaction(trans, info->tree_root);
12547 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12549 struct btrfs_trans_handle *trans;
12550 struct btrfs_block_group_cache *bg_cache;
12554 /* Clear all free space cache inodes and its extent data */
12556 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12559 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12562 current = bg_cache->key.objectid + bg_cache->key.offset;
12565 /* Don't forget to set cache_generation to -1 */
12566 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12567 if (IS_ERR(trans)) {
12568 error("failed to update super block cache generation");
12569 return PTR_ERR(trans);
12571 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12572 btrfs_commit_transaction(trans, fs_info->tree_root);
12577 const char * const cmd_check_usage[] = {
12578 "btrfs check [options] <device>",
12579 "Check structural integrity of a filesystem (unmounted).",
12580 "Check structural integrity of an unmounted filesystem. Verify internal",
12581 "trees' consistency and item connectivity. In the repair mode try to",
12582 "fix the problems found. ",
12583 "WARNING: the repair mode is considered dangerous",
12585 "-s|--super <superblock> use this superblock copy",
12586 "-b|--backup use the first valid backup root copy",
12587 "--repair try to repair the filesystem",
12588 "--readonly run in read-only mode (default)",
12589 "--init-csum-tree create a new CRC tree",
12590 "--init-extent-tree create a new extent tree",
12591 "--mode <MODE> allows choice of memory/IO trade-offs",
12592 " where MODE is one of:",
12593 " original - read inodes and extents to memory (requires",
12594 " more memory, does less IO)",
12595 " lowmem - try to use less memory but read blocks again",
12597 "--check-data-csum verify checksums of data blocks",
12598 "-Q|--qgroup-report print a report on qgroup consistency",
12599 "-E|--subvol-extents <subvolid>",
12600 " print subvolume extents and sharing state",
12601 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12602 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12603 "-p|--progress indicate progress",
12604 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12608 int cmd_check(int argc, char **argv)
12610 struct cache_tree root_cache;
12611 struct btrfs_root *root;
12612 struct btrfs_fs_info *info;
12615 u64 tree_root_bytenr = 0;
12616 u64 chunk_root_bytenr = 0;
12617 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12621 int init_csum_tree = 0;
12623 int clear_space_cache = 0;
12624 int qgroup_report = 0;
12625 int qgroups_repaired = 0;
12626 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12630 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12631 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12632 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12633 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12634 static const struct option long_options[] = {
12635 { "super", required_argument, NULL, 's' },
12636 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12637 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12638 { "init-csum-tree", no_argument, NULL,
12639 GETOPT_VAL_INIT_CSUM },
12640 { "init-extent-tree", no_argument, NULL,
12641 GETOPT_VAL_INIT_EXTENT },
12642 { "check-data-csum", no_argument, NULL,
12643 GETOPT_VAL_CHECK_CSUM },
12644 { "backup", no_argument, NULL, 'b' },
12645 { "subvol-extents", required_argument, NULL, 'E' },
12646 { "qgroup-report", no_argument, NULL, 'Q' },
12647 { "tree-root", required_argument, NULL, 'r' },
12648 { "chunk-root", required_argument, NULL,
12649 GETOPT_VAL_CHUNK_TREE },
12650 { "progress", no_argument, NULL, 'p' },
12651 { "mode", required_argument, NULL,
12653 { "clear-space-cache", required_argument, NULL,
12654 GETOPT_VAL_CLEAR_SPACE_CACHE},
12655 { NULL, 0, NULL, 0}
12658 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
12662 case 'a': /* ignored */ break;
12664 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12667 num = arg_strtou64(optarg);
12668 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12670 "super mirror should be less than %d",
12671 BTRFS_SUPER_MIRROR_MAX);
12674 bytenr = btrfs_sb_offset(((int)num));
12675 printf("using SB copy %llu, bytenr %llu\n", num,
12676 (unsigned long long)bytenr);
12682 subvolid = arg_strtou64(optarg);
12685 tree_root_bytenr = arg_strtou64(optarg);
12687 case GETOPT_VAL_CHUNK_TREE:
12688 chunk_root_bytenr = arg_strtou64(optarg);
12691 ctx.progress_enabled = true;
12695 usage(cmd_check_usage);
12696 case GETOPT_VAL_REPAIR:
12697 printf("enabling repair mode\n");
12699 ctree_flags |= OPEN_CTREE_WRITES;
12701 case GETOPT_VAL_READONLY:
12704 case GETOPT_VAL_INIT_CSUM:
12705 printf("Creating a new CRC tree\n");
12706 init_csum_tree = 1;
12708 ctree_flags |= OPEN_CTREE_WRITES;
12710 case GETOPT_VAL_INIT_EXTENT:
12711 init_extent_tree = 1;
12712 ctree_flags |= (OPEN_CTREE_WRITES |
12713 OPEN_CTREE_NO_BLOCK_GROUPS);
12716 case GETOPT_VAL_CHECK_CSUM:
12717 check_data_csum = 1;
12719 case GETOPT_VAL_MODE:
12720 check_mode = parse_check_mode(optarg);
12721 if (check_mode == CHECK_MODE_UNKNOWN) {
12722 error("unknown mode: %s", optarg);
12726 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12727 if (strcmp(optarg, "v1") == 0) {
12728 clear_space_cache = 1;
12729 } else if (strcmp(optarg, "v2") == 0) {
12730 clear_space_cache = 2;
12731 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12734 "invalid argument to --clear-space-cache, must be v1 or v2");
12737 ctree_flags |= OPEN_CTREE_WRITES;
12742 if (check_argc_exact(argc - optind, 1))
12743 usage(cmd_check_usage);
12745 if (ctx.progress_enabled) {
12746 ctx.tp = TASK_NOTHING;
12747 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12750 /* This check is the only reason for --readonly to exist */
12751 if (readonly && repair) {
12752 error("repair options are not compatible with --readonly");
12757 * Not supported yet
12759 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12760 error("low memory mode doesn't support repair yet");
12765 cache_tree_init(&root_cache);
12767 if((ret = check_mounted(argv[optind])) < 0) {
12768 error("could not check mount status: %s", strerror(-ret));
12772 error("%s is currently mounted, aborting", argv[optind]);
12778 /* only allow partial opening under repair mode */
12780 ctree_flags |= OPEN_CTREE_PARTIAL;
12782 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12783 chunk_root_bytenr, ctree_flags);
12785 error("cannot open file system");
12791 global_info = info;
12792 root = info->fs_root;
12793 if (clear_space_cache == 1) {
12794 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12796 "free space cache v2 detected, use --clear-space-cache v2");
12800 printf("Clearing free space cache\n");
12801 ret = clear_free_space_cache(info);
12803 error("failed to clear free space cache");
12806 printf("Free space cache cleared\n");
12809 } else if (clear_space_cache == 2) {
12810 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12811 printf("no free space cache v2 to clear\n");
12815 printf("Clear free space cache v2\n");
12816 ret = btrfs_clear_free_space_tree(info);
12818 error("failed to clear free space cache v2: %d", ret);
12821 printf("free space cache v2 cleared\n");
12827 * repair mode will force us to commit transaction which
12828 * will make us fail to load log tree when mounting.
12830 if (repair && btrfs_super_log_root(info->super_copy)) {
12831 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12837 ret = zero_log_tree(root);
12840 error("failed to zero log tree: %d", ret);
12845 uuid_unparse(info->super_copy->fsid, uuidbuf);
12846 if (qgroup_report) {
12847 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12849 ret = qgroup_verify_all(info);
12856 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12857 subvolid, argv[optind], uuidbuf);
12858 ret = print_extent_state(info, subvolid);
12862 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12864 if (!extent_buffer_uptodate(info->tree_root->node) ||
12865 !extent_buffer_uptodate(info->dev_root->node) ||
12866 !extent_buffer_uptodate(info->chunk_root->node)) {
12867 error("critical roots corrupted, unable to check the filesystem");
12873 if (init_extent_tree || init_csum_tree) {
12874 struct btrfs_trans_handle *trans;
12876 trans = btrfs_start_transaction(info->extent_root, 0);
12877 if (IS_ERR(trans)) {
12878 error("error starting transaction");
12879 ret = PTR_ERR(trans);
12884 if (init_extent_tree) {
12885 printf("Creating a new extent tree\n");
12886 ret = reinit_extent_tree(trans, info);
12892 if (init_csum_tree) {
12893 printf("Reinitialize checksum tree\n");
12894 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
12896 error("checksum tree initialization failed: %d",
12903 ret = fill_csum_tree(trans, info->csum_root,
12907 error("checksum tree refilling failed: %d", ret);
12912 * Ok now we commit and run the normal fsck, which will add
12913 * extent entries for all of the items it finds.
12915 ret = btrfs_commit_transaction(trans, info->extent_root);
12920 if (!extent_buffer_uptodate(info->extent_root->node)) {
12921 error("critical: extent_root, unable to check the filesystem");
12926 if (!extent_buffer_uptodate(info->csum_root->node)) {
12927 error("critical: csum_root, unable to check the filesystem");
12933 if (!ctx.progress_enabled)
12934 fprintf(stderr, "checking extents\n");
12935 if (check_mode == CHECK_MODE_LOWMEM)
12936 ret = check_chunks_and_extents_v2(root);
12938 ret = check_chunks_and_extents(root);
12942 "errors found in extent allocation tree or chunk allocation");
12944 ret = repair_root_items(info);
12947 error("failed to repair root items: %s", strerror(-ret));
12951 fprintf(stderr, "Fixed %d roots.\n", ret);
12953 } else if (ret > 0) {
12955 "Found %d roots with an outdated root item.\n",
12958 "Please run a filesystem check with the option --repair to fix them.\n");
12964 if (!ctx.progress_enabled) {
12965 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12966 fprintf(stderr, "checking free space tree\n");
12968 fprintf(stderr, "checking free space cache\n");
12970 ret = check_space_cache(root);
12973 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
12974 error("errors found in free space tree");
12976 error("errors found in free space cache");
12981 * We used to have to have these hole extents in between our real
12982 * extents so if we don't have this flag set we need to make sure there
12983 * are no gaps in the file extents for inodes, otherwise we can just
12984 * ignore it when this happens.
12986 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
12987 if (!ctx.progress_enabled)
12988 fprintf(stderr, "checking fs roots\n");
12989 if (check_mode == CHECK_MODE_LOWMEM)
12990 ret = check_fs_roots_v2(root->fs_info);
12992 ret = check_fs_roots(root, &root_cache);
12995 error("errors found in fs roots");
12999 fprintf(stderr, "checking csums\n");
13000 ret = check_csums(root);
13003 error("errors found in csum tree");
13007 fprintf(stderr, "checking root refs\n");
13008 /* For low memory mode, check_fs_roots_v2 handles root refs */
13009 if (check_mode != CHECK_MODE_LOWMEM) {
13010 ret = check_root_refs(root, &root_cache);
13013 error("errors found in root refs");
13018 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
13019 struct extent_buffer *eb;
13021 eb = list_first_entry(&root->fs_info->recow_ebs,
13022 struct extent_buffer, recow);
13023 list_del_init(&eb->recow);
13024 ret = recow_extent_buffer(root, eb);
13027 error("fails to fix transid errors");
13032 while (!list_empty(&delete_items)) {
13033 struct bad_item *bad;
13035 bad = list_first_entry(&delete_items, struct bad_item, list);
13036 list_del_init(&bad->list);
13038 ret = delete_bad_item(root, bad);
13044 if (info->quota_enabled) {
13045 fprintf(stderr, "checking quota groups\n");
13046 ret = qgroup_verify_all(info);
13049 error("failed to check quota groups");
13053 ret = repair_qgroups(info, &qgroups_repaired);
13056 error("failed to repair quota groups");
13062 if (!list_empty(&root->fs_info->recow_ebs)) {
13063 error("transid errors in file system");
13068 if (found_old_backref) { /*
13069 * there was a disk format change when mixed
13070 * backref was in testing tree. The old format
13071 * existed about one week.
13073 printf("\n * Found old mixed backref format. "
13074 "The old format is not supported! *"
13075 "\n * Please mount the FS in readonly mode, "
13076 "backup data and re-format the FS. *\n\n");
13079 printf("found %llu bytes used, ",
13080 (unsigned long long)bytes_used);
13082 printf("error(s) found\n");
13084 printf("no error found\n");
13085 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
13086 printf("total tree bytes: %llu\n",
13087 (unsigned long long)total_btree_bytes);
13088 printf("total fs tree bytes: %llu\n",
13089 (unsigned long long)total_fs_tree_bytes);
13090 printf("total extent tree bytes: %llu\n",
13091 (unsigned long long)total_extent_tree_bytes);
13092 printf("btree space waste bytes: %llu\n",
13093 (unsigned long long)btree_space_waste);
13094 printf("file data blocks allocated: %llu\n referenced %llu\n",
13095 (unsigned long long)data_bytes_allocated,
13096 (unsigned long long)data_bytes_referenced);
13098 free_qgroup_counts();
13099 free_root_recs_tree(&root_cache);
13103 if (ctx.progress_enabled)
13104 task_deinit(ctx.info);