cmds-check.c

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