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