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                             rec->nlink == rec->found_link) {
 815                                 list_del(&backref->list);
 816                                 free(backref);
 817                         }
 818                 }
 819         }
 820
 821         if (!rec->checked || rec->merging)
 822                 return;
 823
 824         if (S_ISDIR(rec->imode)) {
 825                 if (rec->found_size != rec->isize)
 826                         rec->errors |= I_ERR_DIR_ISIZE_WRONG;
 827                 if (rec->found_file_extent)
 828                         rec->errors |= I_ERR_ODD_FILE_EXTENT;
 829         } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
 830                 if (rec->found_dir_item)
 831                         rec->errors |= I_ERR_ODD_DIR_ITEM;
 832                 if (rec->found_size != rec->nbytes)
 833                         rec->errors |= I_ERR_FILE_NBYTES_WRONG;
 834                 if (rec->nlink > 0 && !no_holes &&
 835                     (rec->extent_end < rec->isize ||
 836                      first_extent_gap(&rec->holes) < rec->isize))
 837                         rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
 838         }
 839
 840         if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
 841                 if (rec->found_csum_item && rec->nodatasum)
 842                         rec->errors |= I_ERR_ODD_CSUM_ITEM;
 843                 if (rec->some_csum_missing && !rec->nodatasum)
 844                         rec->errors |= I_ERR_SOME_CSUM_MISSING;
 845         }
 846
 847         BUG_ON(rec->refs != 1);
 848         if (can_free_inode_rec(rec)) {
 849                 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
 850                 node = container_of(cache, struct ptr_node, cache);
 851                 BUG_ON(node->data != rec);
 852                 remove_cache_extent(inode_cache, &node->cache);
 853                 free(node);
 854                 free_inode_rec(rec);
 855         }
 856 }
 857
 858 static int check_orphan_item(struct btrfs_root *root, u64 ino)
 859 {
 860         struct btrfs_path path;
 861         struct btrfs_key key;
 862         int ret;
 863
 864         key.objectid = BTRFS_ORPHAN_OBJECTID;
 865         key.type = BTRFS_ORPHAN_ITEM_KEY;
 866         key.offset = ino;
 867
 868         btrfs_init_path(&path);
 869         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
 870         btrfs_release_path(&path);
 871         if (ret > 0)
 872                 ret = -ENOENT;
 873         return ret;
 874 }
 875
 876 static int process_inode_item(struct extent_buffer *eb,
 877                               int slot, struct btrfs_key *key,
 878                               struct shared_node *active_node)
 879 {
 880         struct inode_record *rec;
 881         struct btrfs_inode_item *item;
 882
 883         rec = active_node->current;
 884         BUG_ON(rec->ino != key->objectid || rec->refs > 1);
 885         if (rec->found_inode_item) {
 886                 rec->errors |= I_ERR_DUP_INODE_ITEM;
 887                 return 1;
 888         }
 889         item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
 890         rec->nlink = btrfs_inode_nlink(eb, item);
 891         rec->isize = btrfs_inode_size(eb, item);
 892         rec->nbytes = btrfs_inode_nbytes(eb, item);
 893         rec->imode = btrfs_inode_mode(eb, item);
 894         if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
 895                 rec->nodatasum = 1;
 896         rec->found_inode_item = 1;
 897         if (rec->nlink == 0)
 898                 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
 899         maybe_free_inode_rec(&active_node->inode_cache, rec);
 900         return 0;
 901 }
 902
 903 static struct inode_backref *get_inode_backref(struct inode_record *rec,
 904                                                 const char *name,
 905                                                 int namelen, u64 dir)
 906 {
 907         struct inode_backref *backref;
 908
 909         list_for_each_entry(backref, &rec->backrefs, list) {
 910                 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
 911                         break;
 912                 if (backref->dir != dir || backref->namelen != namelen)
 913                         continue;
 914                 if (memcmp(name, backref->name, namelen))
 915                         continue;
 916                 return backref;
 917         }
 918
 919         backref = malloc(sizeof(*backref) + namelen + 1);
 920         memset(backref, 0, sizeof(*backref));
 921         backref->dir = dir;
 922         backref->namelen = namelen;
 923         memcpy(backref->name, name, namelen);
 924         backref->name[namelen] = '\0';
 925         list_add_tail(&backref->list, &rec->backrefs);
 926         return backref;
 927 }
 928
 929 static int add_inode_backref(struct cache_tree *inode_cache,
 930                              u64 ino, u64 dir, u64 index,
 931                              const char *name, int namelen,
 932                              int filetype, int itemtype, int errors)
 933 {
 934         struct inode_record *rec;
 935         struct inode_backref *backref;
 936
 937         rec = get_inode_rec(inode_cache, ino, 1);
 938         backref = get_inode_backref(rec, name, namelen, dir);
 939         if (errors)
 940                 backref->errors |= errors;
 941         if (itemtype == BTRFS_DIR_INDEX_KEY) {
 942                 if (backref->found_dir_index)
 943                         backref->errors |= REF_ERR_DUP_DIR_INDEX;
 944                 if (backref->found_inode_ref && backref->index != index)
 945                         backref->errors |= REF_ERR_INDEX_UNMATCH;
 946                 if (backref->found_dir_item && backref->filetype != filetype)
 947                         backref->errors |= REF_ERR_FILETYPE_UNMATCH;
 948
 949                 backref->index = index;
 950                 backref->filetype = filetype;
 951                 backref->found_dir_index = 1;
 952         } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
 953                 rec->found_link++;
 954                 if (backref->found_dir_item)
 955                         backref->errors |= REF_ERR_DUP_DIR_ITEM;
 956                 if (backref->found_dir_index && backref->filetype != filetype)
 957                         backref->errors |= REF_ERR_FILETYPE_UNMATCH;
 958
 959                 backref->filetype = filetype;
 960                 backref->found_dir_item = 1;
 961         } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
 962                    (itemtype == BTRFS_INODE_EXTREF_KEY)) {
 963                 if (backref->found_inode_ref)
 964                         backref->errors |= REF_ERR_DUP_INODE_REF;
 965                 if (backref->found_dir_index && backref->index != index)
 966                         backref->errors |= REF_ERR_INDEX_UNMATCH;
 967                 else
 968                         backref->index = index;
 969
 970                 backref->ref_type = itemtype;
 971                 backref->found_inode_ref = 1;
 972         } else {
 973                 BUG_ON(1);
 974         }
 975
 976         maybe_free_inode_rec(inode_cache, rec);
 977         return 0;
 978 }
 979
 980 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
 981                             struct cache_tree *dst_cache)
 982 {
 983         struct inode_backref *backref;
 984         u32 dir_count = 0;
 985         int ret = 0;
 986
 987         dst->merging = 1;
 988         list_for_each_entry(backref, &src->backrefs, list) {
 989                 if (backref->found_dir_index) {
 990                         add_inode_backref(dst_cache, dst->ino, backref->dir,
 991                                         backref->index, backref->name,
 992                                         backref->namelen, backref->filetype,
 993                                         BTRFS_DIR_INDEX_KEY, backref->errors);
 994                 }
 995                 if (backref->found_dir_item) {
 996                         dir_count++;
 997                         add_inode_backref(dst_cache, dst->ino,
 998                                         backref->dir, 0, backref->name,
 999                                         backref->namelen, backref->filetype,
1000                                         BTRFS_DIR_ITEM_KEY, backref->errors);
1001                 }
1002                 if (backref->found_inode_ref) {
1003                         add_inode_backref(dst_cache, dst->ino,
1004                                         backref->dir, backref->index,
1005                                         backref->name, backref->namelen, 0,
1006                                         backref->ref_type, backref->errors);
1007                 }
1008         }
1009
1010         if (src->found_dir_item)
1011                 dst->found_dir_item = 1;
1012         if (src->found_file_extent)
1013                 dst->found_file_extent = 1;
1014         if (src->found_csum_item)
1015                 dst->found_csum_item = 1;
1016         if (src->some_csum_missing)
1017                 dst->some_csum_missing = 1;
1018         if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1019                 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1020                 if (ret < 0)
1021                         return ret;
1022         }
1023
1024         BUG_ON(src->found_link < dir_count);
1025         dst->found_link += src->found_link - dir_count;
1026         dst->found_size += src->found_size;
1027         if (src->extent_start != (u64)-1) {
1028                 if (dst->extent_start == (u64)-1) {
1029                         dst->extent_start = src->extent_start;
1030                         dst->extent_end = src->extent_end;
1031                 } else {
1032                         if (dst->extent_end > src->extent_start)
1033                                 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1034                         else if (dst->extent_end < src->extent_start) {
1035                                 ret = add_file_extent_hole(&dst->holes,
1036                                         dst->extent_end,
1037                                         src->extent_start - dst->extent_end);
1038                         }
1039                         if (dst->extent_end < src->extent_end)
1040                                 dst->extent_end = src->extent_end;
1041                 }
1042         }
1043
1044         dst->errors |= src->errors;
1045         if (src->found_inode_item) {
1046                 if (!dst->found_inode_item) {
1047                         dst->nlink = src->nlink;
1048                         dst->isize = src->isize;
1049                         dst->nbytes = src->nbytes;
1050                         dst->imode = src->imode;
1051                         dst->nodatasum = src->nodatasum;
1052                         dst->found_inode_item = 1;
1053                 } else {
1054                         dst->errors |= I_ERR_DUP_INODE_ITEM;
1055                 }
1056         }
1057         dst->merging = 0;
1058
1059         return 0;
1060 }
1061
1062 static int splice_shared_node(struct shared_node *src_node,
1063                               struct shared_node *dst_node)
1064 {
1065         struct cache_extent *cache;
1066         struct ptr_node *node, *ins;
1067         struct cache_tree *src, *dst;
1068         struct inode_record *rec, *conflict;
1069         u64 current_ino = 0;
1070         int splice = 0;
1071         int ret;
1072
1073         if (--src_node->refs == 0)
1074                 splice = 1;
1075         if (src_node->current)
1076                 current_ino = src_node->current->ino;
1077
1078         src = &src_node->root_cache;
1079         dst = &dst_node->root_cache;
1080 again:
1081         cache = search_cache_extent(src, 0);
1082         while (cache) {
1083                 node = container_of(cache, struct ptr_node, cache);
1084                 rec = node->data;
1085                 cache = next_cache_extent(cache);
1086
1087                 if (splice) {
1088                         remove_cache_extent(src, &node->cache);
1089                         ins = node;
1090                 } else {
1091                         ins = malloc(sizeof(*ins));
1092                         ins->cache.start = node->cache.start;
1093                         ins->cache.size = node->cache.size;
1094                         ins->data = rec;
1095                         rec->refs++;
1096                 }
1097                 ret = insert_cache_extent(dst, &ins->cache);
1098                 if (ret == -EEXIST) {
1099                         conflict = get_inode_rec(dst, rec->ino, 1);
1100                         merge_inode_recs(rec, conflict, dst);
1101                         if (rec->checked) {
1102                                 conflict->checked = 1;
1103                                 if (dst_node->current == conflict)
1104                                         dst_node->current = NULL;
1105                         }
1106                         maybe_free_inode_rec(dst, conflict);
1107                         free_inode_rec(rec);
1108                         free(ins);
1109                 } else {
1110                         BUG_ON(ret);
1111                 }
1112         }
1113
1114         if (src == &src_node->root_cache) {
1115                 src = &src_node->inode_cache;
1116                 dst = &dst_node->inode_cache;
1117                 goto again;
1118         }
1119
1120         if (current_ino > 0 && (!dst_node->current ||
1121             current_ino > dst_node->current->ino)) {
1122                 if (dst_node->current) {
1123                         dst_node->current->checked = 1;
1124                         maybe_free_inode_rec(dst, dst_node->current);
1125                 }
1126                 dst_node->current = get_inode_rec(dst, current_ino, 1);
1127         }
1128         return 0;
1129 }
1130
1131 static void free_inode_ptr(struct cache_extent *cache)
1132 {
1133         struct ptr_node *node;
1134         struct inode_record *rec;
1135
1136         node = container_of(cache, struct ptr_node, cache);
1137         rec = node->data;
1138         free_inode_rec(rec);
1139         free(node);
1140 }
1141
1142 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1143
1144 static struct shared_node *find_shared_node(struct cache_tree *shared,
1145                                             u64 bytenr)
1146 {
1147         struct cache_extent *cache;
1148         struct shared_node *node;
1149
1150         cache = lookup_cache_extent(shared, bytenr, 1);
1151         if (cache) {
1152                 node = container_of(cache, struct shared_node, cache);
1153                 return node;
1154         }
1155         return NULL;
1156 }
1157
1158 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1159 {
1160         int ret;
1161         struct shared_node *node;
1162
1163         node = calloc(1, sizeof(*node));
1164         node->cache.start = bytenr;
1165         node->cache.size = 1;
1166         cache_tree_init(&node->root_cache);
1167         cache_tree_init(&node->inode_cache);
1168         node->refs = refs;
1169
1170         ret = insert_cache_extent(shared, &node->cache);
1171         BUG_ON(ret);
1172         return 0;
1173 }
1174
1175 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1176                              struct walk_control *wc, int level)
1177 {
1178         struct shared_node *node;
1179         struct shared_node *dest;
1180
1181         if (level == wc->active_node)
1182                 return 0;
1183
1184         BUG_ON(wc->active_node <= level);
1185         node = find_shared_node(&wc->shared, bytenr);
1186         if (!node) {
1187                 add_shared_node(&wc->shared, bytenr, refs);
1188                 node = find_shared_node(&wc->shared, bytenr);
1189                 wc->nodes[level] = node;
1190                 wc->active_node = level;
1191                 return 0;
1192         }
1193
1194         if (wc->root_level == wc->active_node &&
1195             btrfs_root_refs(&root->root_item) == 0) {
1196                 if (--node->refs == 0) {
1197                         free_inode_recs_tree(&node->root_cache);
1198                         free_inode_recs_tree(&node->inode_cache);
1199                         remove_cache_extent(&wc->shared, &node->cache);
1200                         free(node);
1201                 }
1202                 return 1;
1203         }
1204
1205         dest = wc->nodes[wc->active_node];
1206         splice_shared_node(node, dest);
1207         if (node->refs == 0) {
1208                 remove_cache_extent(&wc->shared, &node->cache);
1209                 free(node);
1210         }
1211         return 1;
1212 }
1213
1214 static int leave_shared_node(struct btrfs_root *root,
1215                              struct walk_control *wc, int level)
1216 {
1217         struct shared_node *node;
1218         struct shared_node *dest;
1219         int i;
1220
1221         if (level == wc->root_level)
1222                 return 0;
1223
1224         for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1225                 if (wc->nodes[i])
1226                         break;
1227         }
1228         BUG_ON(i >= BTRFS_MAX_LEVEL);
1229
1230         node = wc->nodes[wc->active_node];
1231         wc->nodes[wc->active_node] = NULL;
1232         wc->active_node = i;
1233
1234         dest = wc->nodes[wc->active_node];
1235         if (wc->active_node < wc->root_level ||
1236             btrfs_root_refs(&root->root_item) > 0) {
1237                 BUG_ON(node->refs <= 1);
1238                 splice_shared_node(node, dest);
1239         } else {
1240                 BUG_ON(node->refs < 2);
1241                 node->refs--;
1242         }
1243         return 0;
1244 }
1245
1246 /*
1247  * Returns:
1248  * < 0 - on error
1249  * 1   - if the root with id child_root_id is a child of root parent_root_id
1250  * 0   - if the root child_root_id isn't a child of the root parent_root_id but
1251  *       has other root(s) as parent(s)
1252  * 2   - if the root child_root_id doesn't have any parent roots
1253  */
1254 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1255                          u64 child_root_id)
1256 {
1257         struct btrfs_path path;
1258         struct btrfs_key key;
1259         struct extent_buffer *leaf;
1260         int has_parent = 0;
1261         int ret;
1262
1263         btrfs_init_path(&path);
1264
1265         key.objectid = parent_root_id;
1266         key.type = BTRFS_ROOT_REF_KEY;
1267         key.offset = child_root_id;
1268         ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1269                                 0, 0);
1270         if (ret < 0)
1271                 return ret;
1272         btrfs_release_path(&path);
1273         if (!ret)
1274                 return 1;
1275
1276         key.objectid = child_root_id;
1277         key.type = BTRFS_ROOT_BACKREF_KEY;
1278         key.offset = 0;
1279         ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1280                                 0, 0);
1281         if (ret < 0)
1282                 goto out;
1283
1284         while (1) {
1285                 leaf = path.nodes[0];
1286                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1287                         ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1288                         if (ret)
1289                                 break;
1290                         leaf = path.nodes[0];
1291                 }
1292
1293                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1294                 if (key.objectid != child_root_id ||
1295                     key.type != BTRFS_ROOT_BACKREF_KEY)
1296                         break;
1297
1298                 has_parent = 1;
1299
1300                 if (key.offset == parent_root_id) {
1301                         btrfs_release_path(&path);
1302                         return 1;
1303                 }
1304
1305                 path.slots[0]++;
1306         }
1307 out:
1308         btrfs_release_path(&path);
1309         if (ret < 0)
1310                 return ret;
1311         return has_parent ? 0 : 2;
1312 }
1313
1314 static int process_dir_item(struct btrfs_root *root,
1315                             struct extent_buffer *eb,
1316                             int slot, struct btrfs_key *key,
1317                             struct shared_node *active_node)
1318 {
1319         u32 total;
1320         u32 cur = 0;
1321         u32 len;
1322         u32 name_len;
1323         u32 data_len;
1324         int error;
1325         int nritems = 0;
1326         int filetype;
1327         struct btrfs_dir_item *di;
1328         struct inode_record *rec;
1329         struct cache_tree *root_cache;
1330         struct cache_tree *inode_cache;
1331         struct btrfs_key location;
1332         char namebuf[BTRFS_NAME_LEN];
1333
1334         root_cache = &active_node->root_cache;
1335         inode_cache = &active_node->inode_cache;
1336         rec = active_node->current;
1337         rec->found_dir_item = 1;
1338
1339         di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1340         total = btrfs_item_size_nr(eb, slot);
1341         while (cur < total) {
1342                 nritems++;
1343                 btrfs_dir_item_key_to_cpu(eb, di, &location);
1344                 name_len = btrfs_dir_name_len(eb, di);
1345                 data_len = btrfs_dir_data_len(eb, di);
1346                 filetype = btrfs_dir_type(eb, di);
1347
1348                 rec->found_size += name_len;
1349                 if (name_len <= BTRFS_NAME_LEN) {
1350                         len = name_len;
1351                         error = 0;
1352                 } else {
1353                         len = BTRFS_NAME_LEN;
1354                         error = REF_ERR_NAME_TOO_LONG;
1355                 }
1356                 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1357
1358                 if (location.type == BTRFS_INODE_ITEM_KEY) {
1359                         add_inode_backref(inode_cache, location.objectid,
1360                                           key->objectid, key->offset, namebuf,
1361                                           len, filetype, key->type, error);
1362                 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1363                         add_inode_backref(root_cache, location.objectid,
1364                                           key->objectid, key->offset,
1365                                           namebuf, len, filetype,
1366                                           key->type, error);
1367                 } else {
1368                         fprintf(stderr, "invalid location in dir item %u\n",
1369                                 location.type);
1370                         add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1371                                           key->objectid, key->offset, namebuf,
1372                                           len, filetype, key->type, error);
1373                 }
1374
1375                 len = sizeof(*di) + name_len + data_len;
1376                 di = (struct btrfs_dir_item *)((char *)di + len);
1377                 cur += len;
1378         }
1379         if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1380                 rec->errors |= I_ERR_DUP_DIR_INDEX;
1381
1382         return 0;
1383 }
1384
1385 static int process_inode_ref(struct extent_buffer *eb,
1386                              int slot, struct btrfs_key *key,
1387                              struct shared_node *active_node)
1388 {
1389         u32 total;
1390         u32 cur = 0;
1391         u32 len;
1392         u32 name_len;
1393         u64 index;
1394         int error;
1395         struct cache_tree *inode_cache;
1396         struct btrfs_inode_ref *ref;
1397         char namebuf[BTRFS_NAME_LEN];
1398
1399         inode_cache = &active_node->inode_cache;
1400
1401         ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1402         total = btrfs_item_size_nr(eb, slot);
1403         while (cur < total) {
1404                 name_len = btrfs_inode_ref_name_len(eb, ref);
1405                 index = btrfs_inode_ref_index(eb, ref);
1406                 if (name_len <= BTRFS_NAME_LEN) {
1407                         len = name_len;
1408                         error = 0;
1409                 } else {
1410                         len = BTRFS_NAME_LEN;
1411                         error = REF_ERR_NAME_TOO_LONG;
1412                 }
1413                 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1414                 add_inode_backref(inode_cache, key->objectid, key->offset,
1415                                   index, namebuf, len, 0, key->type, error);
1416
1417                 len = sizeof(*ref) + name_len;
1418                 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1419                 cur += len;
1420         }
1421         return 0;
1422 }
1423
1424 static int process_inode_extref(struct extent_buffer *eb,
1425                                 int slot, struct btrfs_key *key,
1426                                 struct shared_node *active_node)
1427 {
1428         u32 total;
1429         u32 cur = 0;
1430         u32 len;
1431         u32 name_len;
1432         u64 index;
1433         u64 parent;
1434         int error;
1435         struct cache_tree *inode_cache;
1436         struct btrfs_inode_extref *extref;
1437         char namebuf[BTRFS_NAME_LEN];
1438
1439         inode_cache = &active_node->inode_cache;
1440
1441         extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1442         total = btrfs_item_size_nr(eb, slot);
1443         while (cur < total) {
1444                 name_len = btrfs_inode_extref_name_len(eb, extref);
1445                 index = btrfs_inode_extref_index(eb, extref);
1446                 parent = btrfs_inode_extref_parent(eb, extref);
1447                 if (name_len <= BTRFS_NAME_LEN) {
1448                         len = name_len;
1449                         error = 0;
1450                 } else {
1451                         len = BTRFS_NAME_LEN;
1452                         error = REF_ERR_NAME_TOO_LONG;
1453                 }
1454                 read_extent_buffer(eb, namebuf,
1455                                    (unsigned long)(extref + 1), len);
1456                 add_inode_backref(inode_cache, key->objectid, parent,
1457                                   index, namebuf, len, 0, key->type, error);
1458
1459                 len = sizeof(*extref) + name_len;
1460                 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1461                 cur += len;
1462         }
1463         return 0;
1464
1465 }
1466
1467 static int count_csum_range(struct btrfs_root *root, u64 start,
1468                             u64 len, u64 *found)
1469 {
1470         struct btrfs_key key;
1471         struct btrfs_path path;
1472         struct extent_buffer *leaf;
1473         int ret;
1474         size_t size;
1475         *found = 0;
1476         u64 csum_end;
1477         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1478
1479         btrfs_init_path(&path);
1480
1481         key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1482         key.offset = start;
1483         key.type = BTRFS_EXTENT_CSUM_KEY;
1484
1485         ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1486                                 &key, &path, 0, 0);
1487         if (ret < 0)
1488                 goto out;
1489         if (ret > 0 && path.slots[0] > 0) {
1490                 leaf = path.nodes[0];
1491                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1492                 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1493                     key.type == BTRFS_EXTENT_CSUM_KEY)
1494                         path.slots[0]--;
1495         }
1496
1497         while (len > 0) {
1498                 leaf = path.nodes[0];
1499                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1500                         ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1501                         if (ret > 0)
1502                                 break;
1503                         else if (ret < 0)
1504                                 goto out;
1505                         leaf = path.nodes[0];
1506                 }
1507
1508                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1509                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1510                     key.type != BTRFS_EXTENT_CSUM_KEY)
1511                         break;
1512
1513                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1514                 if (key.offset >= start + len)
1515                         break;
1516
1517                 if (key.offset > start)
1518                         start = key.offset;
1519
1520                 size = btrfs_item_size_nr(leaf, path.slots[0]);
1521                 csum_end = key.offset + (size / csum_size) * root->sectorsize;
1522                 if (csum_end > start) {
1523                         size = min(csum_end - start, len);
1524                         len -= size;
1525                         start += size;
1526                         *found += size;
1527                 }
1528
1529                 path.slots[0]++;
1530         }
1531 out:
1532         btrfs_release_path(&path);
1533         if (ret < 0)
1534                 return ret;
1535         return 0;
1536 }
1537
1538 static int process_file_extent(struct btrfs_root *root,
1539                                 struct extent_buffer *eb,
1540                                 int slot, struct btrfs_key *key,
1541                                 struct shared_node *active_node)
1542 {
1543         struct inode_record *rec;
1544         struct btrfs_file_extent_item *fi;
1545         u64 num_bytes = 0;
1546         u64 disk_bytenr = 0;
1547         u64 extent_offset = 0;
1548         u64 mask = root->sectorsize - 1;
1549         int extent_type;
1550         int ret;
1551
1552         rec = active_node->current;
1553         BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1554         rec->found_file_extent = 1;
1555
1556         if (rec->extent_start == (u64)-1) {
1557                 rec->extent_start = key->offset;
1558                 rec->extent_end = key->offset;
1559         }
1560
1561         if (rec->extent_end > key->offset)
1562                 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1563         else if (rec->extent_end < key->offset) {
1564                 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1565                                            key->offset - rec->extent_end);
1566                 if (ret < 0)
1567                         return ret;
1568         }
1569
1570         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1571         extent_type = btrfs_file_extent_type(eb, fi);
1572
1573         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1574                 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1575                 if (num_bytes == 0)
1576                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1577                 rec->found_size += num_bytes;
1578                 num_bytes = (num_bytes + mask) & ~mask;
1579         } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1580                    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1581                 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1582                 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1583                 extent_offset = btrfs_file_extent_offset(eb, fi);
1584                 if (num_bytes == 0 || (num_bytes & mask))
1585                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1586                 if (num_bytes + extent_offset >
1587                     btrfs_file_extent_ram_bytes(eb, fi))
1588                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1589                 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1590                     (btrfs_file_extent_compression(eb, fi) ||
1591                      btrfs_file_extent_encryption(eb, fi) ||
1592                      btrfs_file_extent_other_encoding(eb, fi)))
1593                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1594                 if (disk_bytenr > 0)
1595                         rec->found_size += num_bytes;
1596         } else {
1597                 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1598         }
1599         rec->extent_end = key->offset + num_bytes;
1600
1601         /*
1602          * The data reloc tree will copy full extents into its inode and then
1603          * copy the corresponding csums.  Because the extent it copied could be
1604          * a preallocated extent that hasn't been written to yet there may be no
1605          * csums to copy, ergo we won't have csums for our file extent.  This is
1606          * ok so just don't bother checking csums if the inode belongs to the
1607          * data reloc tree.
1608          */
1609         if (disk_bytenr > 0 &&
1610             btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1611                 u64 found;
1612                 if (btrfs_file_extent_compression(eb, fi))
1613                         num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1614                 else
1615                         disk_bytenr += extent_offset;
1616
1617                 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1618                 if (ret < 0)
1619                         return ret;
1620                 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1621                         if (found > 0)
1622                                 rec->found_csum_item = 1;
1623                         if (found < num_bytes)
1624                                 rec->some_csum_missing = 1;
1625                 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1626                         if (found > 0)
1627                                 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1628                 }
1629         }
1630         return 0;
1631 }
1632
1633 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1634                             struct walk_control *wc)
1635 {
1636         struct btrfs_key key;
1637         u32 nritems;
1638         int i;
1639         int ret = 0;
1640         struct cache_tree *inode_cache;
1641         struct shared_node *active_node;
1642
1643         if (wc->root_level == wc->active_node &&
1644             btrfs_root_refs(&root->root_item) == 0)
1645                 return 0;
1646
1647         active_node = wc->nodes[wc->active_node];
1648         inode_cache = &active_node->inode_cache;
1649         nritems = btrfs_header_nritems(eb);
1650         for (i = 0; i < nritems; i++) {
1651                 btrfs_item_key_to_cpu(eb, &key, i);
1652
1653                 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1654                         continue;
1655                 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1656                         continue;
1657
1658                 if (active_node->current == NULL ||
1659                     active_node->current->ino < key.objectid) {
1660                         if (active_node->current) {
1661                                 active_node->current->checked = 1;
1662                                 maybe_free_inode_rec(inode_cache,
1663                                                      active_node->current);
1664                         }
1665                         active_node->current = get_inode_rec(inode_cache,
1666                                                              key.objectid, 1);
1667                 }
1668                 switch (key.type) {
1669                 case BTRFS_DIR_ITEM_KEY:
1670                 case BTRFS_DIR_INDEX_KEY:
1671                         ret = process_dir_item(root, eb, i, &key, active_node);
1672                         break;
1673                 case BTRFS_INODE_REF_KEY:
1674                         ret = process_inode_ref(eb, i, &key, active_node);
1675                         break;
1676                 case BTRFS_INODE_EXTREF_KEY:
1677                         ret = process_inode_extref(eb, i, &key, active_node);
1678                         break;
1679                 case BTRFS_INODE_ITEM_KEY:
1680                         ret = process_inode_item(eb, i, &key, active_node);
1681                         break;
1682                 case BTRFS_EXTENT_DATA_KEY:
1683                         ret = process_file_extent(root, eb, i, &key,
1684                                                   active_node);
1685                         break;
1686                 default:
1687                         break;
1688                 };
1689         }
1690         return ret;
1691 }
1692
1693 static void reada_walk_down(struct btrfs_root *root,
1694                             struct extent_buffer *node, int slot)
1695 {
1696         u64 bytenr;
1697         u64 ptr_gen;
1698         u32 nritems;
1699         u32 blocksize;
1700         int i;
1701         int level;
1702
1703         level = btrfs_header_level(node);
1704         if (level != 1)
1705                 return;
1706
1707         nritems = btrfs_header_nritems(node);
1708         blocksize = btrfs_level_size(root, level - 1);
1709         for (i = slot; i < nritems; i++) {
1710                 bytenr = btrfs_node_blockptr(node, i);
1711                 ptr_gen = btrfs_node_ptr_generation(node, i);
1712                 readahead_tree_block(root, bytenr, blocksize, ptr_gen);
1713         }
1714 }
1715
1716 /*
1717  * Check the child node/leaf by the following condition:
1718  * 1. the first item key of the node/leaf should be the same with the one
1719  *    in parent.
1720  * 2. block in parent node should match the child node/leaf.
1721  * 3. generation of parent node and child's header should be consistent.
1722  *
1723  * Or the child node/leaf pointed by the key in parent is not valid.
1724  *
1725  * We hope to check leaf owner too, but since subvol may share leaves,
1726  * which makes leaf owner check not so strong, key check should be
1727  * sufficient enough for that case.
1728  */
1729 static int check_child_node(struct btrfs_root *root,
1730                             struct extent_buffer *parent, int slot,
1731                             struct extent_buffer *child)
1732 {
1733         struct btrfs_key parent_key;
1734         struct btrfs_key child_key;
1735         int ret = 0;
1736
1737         btrfs_node_key_to_cpu(parent, &parent_key, slot);
1738         if (btrfs_header_level(child) == 0)
1739                 btrfs_item_key_to_cpu(child, &child_key, 0);
1740         else
1741                 btrfs_node_key_to_cpu(child, &child_key, 0);
1742
1743         if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
1744                 ret = -EINVAL;
1745                 fprintf(stderr,
1746                         "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
1747                         parent_key.objectid, parent_key.type, parent_key.offset,
1748                         child_key.objectid, child_key.type, child_key.offset);
1749         }
1750         if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
1751                 ret = -EINVAL;
1752                 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
1753                         btrfs_node_blockptr(parent, slot),
1754                         btrfs_header_bytenr(child));
1755         }
1756         if (btrfs_node_ptr_generation(parent, slot) !=
1757             btrfs_header_generation(child)) {
1758                 ret = -EINVAL;
1759                 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
1760                         btrfs_header_generation(child),
1761                         btrfs_node_ptr_generation(parent, slot));
1762         }
1763         return ret;
1764 }
1765
1766 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
1767                           struct walk_control *wc, int *level)
1768 {
1769         enum btrfs_tree_block_status status;
1770         u64 bytenr;
1771         u64 ptr_gen;
1772         struct extent_buffer *next;
1773         struct extent_buffer *cur;
1774         u32 blocksize;
1775         int ret, err = 0;
1776         u64 refs;
1777
1778         WARN_ON(*level < 0);
1779         WARN_ON(*level >= BTRFS_MAX_LEVEL);
1780         ret = btrfs_lookup_extent_info(NULL, root,
1781                                        path->nodes[*level]->start,
1782                                        *level, 1, &refs, NULL);
1783         if (ret < 0) {
1784                 err = ret;
1785                 goto out;
1786         }
1787
1788         if (refs > 1) {
1789                 ret = enter_shared_node(root, path->nodes[*level]->start,
1790                                         refs, wc, *level);
1791                 if (ret > 0) {
1792                         err = ret;
1793                         goto out;
1794                 }
1795         }
1796
1797         while (*level >= 0) {
1798                 WARN_ON(*level < 0);
1799                 WARN_ON(*level >= BTRFS_MAX_LEVEL);
1800                 cur = path->nodes[*level];
1801
1802                 if (btrfs_header_level(cur) != *level)
1803                         WARN_ON(1);
1804
1805                 if (path->slots[*level] >= btrfs_header_nritems(cur))
1806                         break;
1807                 if (*level == 0) {
1808                         ret = process_one_leaf(root, cur, wc);
1809                         if (ret < 0)
1810                                 err = ret;
1811                         break;
1812                 }
1813                 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
1814                 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
1815                 blocksize = btrfs_level_size(root, *level - 1);
1816                 ret = btrfs_lookup_extent_info(NULL, root, bytenr, *level - 1,
1817                                                1, &refs, NULL);
1818                 if (ret < 0)
1819                         refs = 0;
1820
1821                 if (refs > 1) {
1822                         ret = enter_shared_node(root, bytenr, refs,
1823                                                 wc, *level - 1);
1824                         if (ret > 0) {
1825                                 path->slots[*level]++;
1826                                 continue;
1827                         }
1828                 }
1829
1830                 next = btrfs_find_tree_block(root, bytenr, blocksize);
1831                 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
1832                         free_extent_buffer(next);
1833                         reada_walk_down(root, cur, path->slots[*level]);
1834                         next = read_tree_block(root, bytenr, blocksize,
1835                                                ptr_gen);
1836                         if (!extent_buffer_uptodate(next)) {
1837                                 struct btrfs_key node_key;
1838
1839                                 btrfs_node_key_to_cpu(path->nodes[*level],
1840                                                       &node_key,
1841                                                       path->slots[*level]);
1842                                 btrfs_add_corrupt_extent_record(root->fs_info,
1843                                                 &node_key,
1844                                                 path->nodes[*level]->start,
1845                                                 root->leafsize, *level);
1846                                 err = -EIO;
1847                                 goto out;
1848                         }
1849                 }
1850
1851                 ret = check_child_node(root, cur, path->slots[*level], next);
1852                 if (ret) {
1853                         err = ret;
1854                         goto out;
1855                 }
1856
1857                 if (btrfs_is_leaf(next))
1858                         status = btrfs_check_leaf(root, NULL, next);
1859                 else
1860                         status = btrfs_check_node(root, NULL, next);
1861                 if (status != BTRFS_TREE_BLOCK_CLEAN) {
1862                         free_extent_buffer(next);
1863                         err = -EIO;
1864                         goto out;
1865                 }
1866
1867                 *level = *level - 1;
1868                 free_extent_buffer(path->nodes[*level]);
1869                 path->nodes[*level] = next;
1870                 path->slots[*level] = 0;
1871         }
1872 out:
1873         path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
1874         return err;
1875 }
1876
1877 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
1878                         struct walk_control *wc, int *level)
1879 {
1880         int i;
1881         struct extent_buffer *leaf;
1882
1883         for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
1884                 leaf = path->nodes[i];
1885                 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
1886                         path->slots[i]++;
1887                         *level = i;
1888                         return 0;
1889                 } else {
1890                         free_extent_buffer(path->nodes[*level]);
1891                         path->nodes[*level] = NULL;
1892                         BUG_ON(*level > wc->active_node);
1893                         if (*level == wc->active_node)
1894                                 leave_shared_node(root, wc, *level);
1895                         *level = i + 1;
1896                 }
1897         }
1898         return 1;
1899 }
1900
1901 static int check_root_dir(struct inode_record *rec)
1902 {
1903         struct inode_backref *backref;
1904         int ret = -1;
1905
1906         if (!rec->found_inode_item || rec->errors)
1907                 goto out;
1908         if (rec->nlink != 1 || rec->found_link != 0)
1909                 goto out;
1910         if (list_empty(&rec->backrefs))
1911                 goto out;
1912         backref = list_entry(rec->backrefs.next, struct inode_backref, list);
1913         if (!backref->found_inode_ref)
1914                 goto out;
1915         if (backref->index != 0 || backref->namelen != 2 ||
1916             memcmp(backref->name, "..", 2))
1917                 goto out;
1918         if (backref->found_dir_index || backref->found_dir_item)
1919                 goto out;
1920         ret = 0;
1921 out:
1922         return ret;
1923 }
1924
1925 static int repair_inode_isize(struct btrfs_trans_handle *trans,
1926                               struct btrfs_root *root, struct btrfs_path *path,
1927                               struct inode_record *rec)
1928 {
1929         struct btrfs_inode_item *ei;
1930         struct btrfs_key key;
1931         int ret;
1932
1933         key.objectid = rec->ino;
1934         key.type = BTRFS_INODE_ITEM_KEY;
1935         key.offset = (u64)-1;
1936
1937         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1938         if (ret < 0)
1939                 goto out;
1940         if (ret) {
1941                 if (!path->slots[0]) {
1942                         ret = -ENOENT;
1943                         goto out;
1944                 }
1945                 path->slots[0]--;
1946                 ret = 0;
1947         }
1948         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
1949         if (key.objectid != rec->ino) {
1950                 ret = -ENOENT;
1951                 goto out;
1952         }
1953
1954         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
1955                             struct btrfs_inode_item);
1956         btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
1957         btrfs_mark_buffer_dirty(path->nodes[0]);
1958         rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
1959         printf("reset isize for dir %Lu root %Lu\n", rec->ino,
1960                root->root_key.objectid);
1961 out:
1962         btrfs_release_path(path);
1963         return ret;
1964 }
1965
1966 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
1967                                     struct btrfs_root *root,
1968                                     struct btrfs_path *path,
1969                                     struct inode_record *rec)
1970 {
1971         int ret;
1972
1973         ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
1974         btrfs_release_path(path);
1975         if (!ret)
1976                 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
1977         return ret;
1978 }
1979
1980 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
1981                                struct btrfs_root *root,
1982                                struct btrfs_path *path,
1983                                struct inode_record *rec)
1984 {
1985         struct btrfs_inode_item *ei;
1986         struct btrfs_key key;
1987         int ret = 0;
1988
1989         key.objectid = rec->ino;
1990         key.type = BTRFS_INODE_ITEM_KEY;
1991         key.offset = 0;
1992
1993         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1994         if (ret) {
1995                 if (ret > 0)
1996                         ret = -ENOENT;
1997                 goto out;
1998         }
1999
2000         /* Since ret == 0, no need to check anything */
2001         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2002                             struct btrfs_inode_item);
2003         btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2004         btrfs_mark_buffer_dirty(path->nodes[0]);
2005         rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2006         printf("reset nbytes for ino %llu root %llu\n",
2007                rec->ino, root->root_key.objectid);
2008 out:
2009         btrfs_release_path(path);
2010         return ret;
2011 }
2012
2013 static int add_missing_dir_index(struct btrfs_root *root,
2014                                  struct cache_tree *inode_cache,
2015                                  struct inode_record *rec,
2016                                  struct inode_backref *backref)
2017 {
2018         struct btrfs_path *path;
2019         struct btrfs_trans_handle *trans;
2020         struct btrfs_dir_item *dir_item;
2021         struct extent_buffer *leaf;
2022         struct btrfs_key key;
2023         struct btrfs_disk_key disk_key;
2024         struct inode_record *dir_rec;
2025         unsigned long name_ptr;
2026         u32 data_size = sizeof(*dir_item) + backref->namelen;
2027         int ret;
2028
2029         path = btrfs_alloc_path();
2030         if (!path)
2031                 return -ENOMEM;
2032
2033         trans = btrfs_start_transaction(root, 1);
2034         if (IS_ERR(trans)) {
2035                 btrfs_free_path(path);
2036                 return PTR_ERR(trans);
2037         }
2038
2039         fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2040                 (unsigned long long)rec->ino);
2041         key.objectid = backref->dir;
2042         key.type = BTRFS_DIR_INDEX_KEY;
2043         key.offset = backref->index;
2044
2045         ret = btrfs_insert_empty_item(trans, root, path, &key, data_size);
2046         BUG_ON(ret);
2047
2048         leaf = path->nodes[0];
2049         dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);
2050
2051         disk_key.objectid = cpu_to_le64(rec->ino);
2052         disk_key.type = BTRFS_INODE_ITEM_KEY;
2053         disk_key.offset = 0;
2054
2055         btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2056         btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2057         btrfs_set_dir_data_len(leaf, dir_item, 0);
2058         btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2059         name_ptr = (unsigned long)(dir_item + 1);
2060         write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2061         btrfs_mark_buffer_dirty(leaf);
2062         btrfs_free_path(path);
2063         btrfs_commit_transaction(trans, root);
2064
2065         backref->found_dir_index = 1;
2066         dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2067         if (!dir_rec)
2068                 return 0;
2069         dir_rec->found_size += backref->namelen;
2070         if (dir_rec->found_size == dir_rec->isize &&
2071             (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2072                 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2073         if (dir_rec->found_size != dir_rec->isize)
2074                 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2075
2076         return 0;
2077 }
2078
2079 static int delete_dir_index(struct btrfs_root *root,
2080                             struct cache_tree *inode_cache,
2081                             struct inode_record *rec,
2082                             struct inode_backref *backref)
2083 {
2084         struct btrfs_trans_handle *trans;
2085         struct btrfs_dir_item *di;
2086         struct btrfs_path *path;
2087         int ret = 0;
2088
2089         path = btrfs_alloc_path();
2090         if (!path)
2091                 return -ENOMEM;
2092
2093         trans = btrfs_start_transaction(root, 1);
2094         if (IS_ERR(trans)) {
2095                 btrfs_free_path(path);
2096                 return PTR_ERR(trans);
2097         }
2098
2099
2100         fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2101                 (unsigned long long)backref->dir,
2102                 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2103                 (unsigned long long)root->objectid);
2104
2105         di = btrfs_lookup_dir_index(trans, root, path, backref->dir,
2106                                     backref->name, backref->namelen,
2107                                     backref->index, -1);
2108         if (IS_ERR(di)) {
2109                 ret = PTR_ERR(di);
2110                 btrfs_free_path(path);
2111                 btrfs_commit_transaction(trans, root);
2112                 if (ret == -ENOENT)
2113                         return 0;
2114                 return ret;
2115         }
2116
2117         if (!di)
2118                 ret = btrfs_del_item(trans, root, path);
2119         else
2120                 ret = btrfs_delete_one_dir_name(trans, root, path, di);
2121         BUG_ON(ret);
2122         btrfs_free_path(path);
2123         btrfs_commit_transaction(trans, root);
2124         return ret;
2125 }
2126
2127 static int create_inode_item(struct btrfs_root *root,
2128                              struct inode_record *rec,
2129                              struct inode_backref *backref, int root_dir)
2130 {
2131         struct btrfs_trans_handle *trans;
2132         struct btrfs_inode_item inode_item;
2133         time_t now = time(NULL);
2134         int ret;
2135
2136         trans = btrfs_start_transaction(root, 1);
2137         if (IS_ERR(trans)) {
2138                 ret = PTR_ERR(trans);
2139                 return ret;
2140         }
2141
2142         fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2143                 "be incomplete, please check permissions and content after "
2144                 "the fsck completes.\n", (unsigned long long)root->objectid,
2145                 (unsigned long long)rec->ino);
2146
2147         memset(&inode_item, 0, sizeof(inode_item));
2148         btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2149         if (root_dir)
2150                 btrfs_set_stack_inode_nlink(&inode_item, 1);
2151         else
2152                 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2153         btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2154         if (rec->found_dir_item) {
2155                 if (rec->found_file_extent)
2156                         fprintf(stderr, "root %llu inode %llu has both a dir "
2157                                 "item and extents, unsure if it is a dir or a "
2158                                 "regular file so setting it as a directory\n",
2159                                 (unsigned long long)root->objectid,
2160                                 (unsigned long long)rec->ino);
2161                 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2162                 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2163         } else if (!rec->found_dir_item) {
2164                 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2165                 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2166         }
2167         btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2168         btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2169         btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2170         btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2171         btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2172         btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2173         btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2174         btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2175
2176         ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2177         BUG_ON(ret);
2178         btrfs_commit_transaction(trans, root);
2179         return 0;
2180 }
2181
2182 static int repair_inode_backrefs(struct btrfs_root *root,
2183                                  struct inode_record *rec,
2184                                  struct cache_tree *inode_cache,
2185                                  int delete)
2186 {
2187         struct inode_backref *tmp, *backref;
2188         u64 root_dirid = btrfs_root_dirid(&root->root_item);
2189         int ret = 0;
2190         int repaired = 0;
2191
2192         list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2193                 if (!delete && rec->ino == root_dirid) {
2194                         if (!rec->found_inode_item) {
2195                                 ret = create_inode_item(root, rec, backref, 1);
2196                                 if (ret)
2197                                         break;
2198                                 repaired++;
2199                         }
2200                 }
2201
2202                 /* Index 0 for root dir's are special, don't mess with it */
2203                 if (rec->ino == root_dirid && backref->index == 0)
2204                         continue;
2205
2206                 if (delete &&
2207                     ((backref->found_dir_index && !backref->found_inode_ref) ||
2208                      (backref->found_dir_index && backref->found_inode_ref &&
2209                       (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2210                         ret = delete_dir_index(root, inode_cache, rec, backref);
2211                         if (ret)
2212                                 break;
2213                         repaired++;
2214                         list_del(&backref->list);
2215                         free(backref);
2216                 }
2217
2218                 if (!delete && !backref->found_dir_index &&
2219                     backref->found_dir_item && backref->found_inode_ref) {
2220                         ret = add_missing_dir_index(root, inode_cache, rec,
2221                                                     backref);
2222                         if (ret)
2223                                 break;
2224                         repaired++;
2225                         if (backref->found_dir_item &&
2226                             backref->found_dir_index &&
2227                             backref->found_dir_index) {
2228                                 if (!backref->errors &&
2229                                     backref->found_inode_ref) {
2230                                         list_del(&backref->list);
2231                                         free(backref);
2232                                 }
2233                         }
2234                 }
2235
2236                 if (!delete && (!backref->found_dir_index &&
2237                                 !backref->found_dir_item &&
2238                                 backref->found_inode_ref)) {
2239                         struct btrfs_trans_handle *trans;
2240                         struct btrfs_key location;
2241
2242                         ret = check_dir_conflict(root, backref->name,
2243                                                  backref->namelen,
2244                                                  backref->dir,
2245                                                  backref->index);
2246                         if (ret) {
2247                                 /*
2248                                  * let nlink fixing routine to handle it,
2249                                  * which can do it better.
2250                                  */
2251                                 ret = 0;
2252                                 break;
2253                         }
2254                         location.objectid = rec->ino;
2255                         location.type = BTRFS_INODE_ITEM_KEY;
2256                         location.offset = 0;
2257
2258                         trans = btrfs_start_transaction(root, 1);
2259                         if (IS_ERR(trans)) {
2260                                 ret = PTR_ERR(trans);
2261                                 break;
2262                         }
2263                         fprintf(stderr, "adding missing dir index/item pair "
2264                                 "for inode %llu\n",
2265                                 (unsigned long long)rec->ino);
2266                         ret = btrfs_insert_dir_item(trans, root, backref->name,
2267                                                     backref->namelen,
2268                                                     backref->dir, &location,
2269                                                     imode_to_type(rec->imode),
2270                                                     backref->index);
2271                         BUG_ON(ret);
2272                         btrfs_commit_transaction(trans, root);
2273                         repaired++;
2274                 }
2275
2276                 if (!delete && (backref->found_inode_ref &&
2277                                 backref->found_dir_index &&
2278                                 backref->found_dir_item &&
2279                                 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2280                                 !rec->found_inode_item)) {
2281                         ret = create_inode_item(root, rec, backref, 0);
2282                         if (ret)
2283                                 break;
2284                         repaired++;
2285                 }
2286
2287         }
2288         return ret ? ret : repaired;
2289 }
2290
2291 /*
2292  * To determine the file type for nlink/inode_item repair
2293  *
2294  * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2295  * Return -ENOENT if file type is not found.
2296  */
2297 static int find_file_type(struct inode_record *rec, u8 *type)
2298 {
2299         struct inode_backref *backref;
2300
2301         /* For inode item recovered case */
2302         if (rec->found_inode_item) {
2303                 *type = imode_to_type(rec->imode);
2304                 return 0;
2305         }
2306
2307         list_for_each_entry(backref, &rec->backrefs, list) {
2308                 if (backref->found_dir_index || backref->found_dir_item) {
2309                         *type = backref->filetype;
2310                         return 0;
2311                 }
2312         }
2313         return -ENOENT;
2314 }
2315
2316 /*
2317  * To determine the file name for nlink repair
2318  *
2319  * Return 0 if file name is found, set name and namelen.
2320  * Return -ENOENT if file name is not found.
2321  */
2322 static int find_file_name(struct inode_record *rec,
2323                           char *name, int *namelen)
2324 {
2325         struct inode_backref *backref;
2326
2327         list_for_each_entry(backref, &rec->backrefs, list) {
2328                 if (backref->found_dir_index || backref->found_dir_item ||
2329                     backref->found_inode_ref) {
2330                         memcpy(name, backref->name, backref->namelen);
2331                         *namelen = backref->namelen;
2332                         return 0;
2333                 }
2334         }
2335         return -ENOENT;
2336 }
2337
2338 /* Reset the nlink of the inode to the correct one */
2339 static int reset_nlink(struct btrfs_trans_handle *trans,
2340                        struct btrfs_root *root,
2341                        struct btrfs_path *path,
2342                        struct inode_record *rec)
2343 {
2344         struct inode_backref *backref;
2345         struct inode_backref *tmp;
2346         struct btrfs_key key;
2347         struct btrfs_inode_item *inode_item;
2348         int ret = 0;
2349
2350         /* We don't believe this either, reset it and iterate backref */
2351         rec->found_link = 0;
2352
2353         /* Remove all backref including the valid ones */
2354         list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2355                 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2356                                    backref->index, backref->name,
2357                                    backref->namelen, 0);
2358                 if (ret < 0)
2359                         goto out;
2360
2361                 /* remove invalid backref, so it won't be added back */
2362                 if (!(backref->found_dir_index &&
2363                       backref->found_dir_item &&
2364                       backref->found_inode_ref)) {
2365                         list_del(&backref->list);
2366                         free(backref);
2367                 } else {
2368                         rec->found_link++;
2369                 }
2370         }
2371
2372         /* Set nlink to 0 */
2373         key.objectid = rec->ino;
2374         key.type = BTRFS_INODE_ITEM_KEY;
2375         key.offset = 0;
2376         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2377         if (ret < 0)
2378                 goto out;
2379         if (ret > 0) {
2380                 ret = -ENOENT;
2381                 goto out;
2382         }
2383         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2384                                     struct btrfs_inode_item);
2385         btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2386         btrfs_mark_buffer_dirty(path->nodes[0]);
2387         btrfs_release_path(path);
2388
2389         /*
2390          * Add back valid inode_ref/dir_item/dir_index,
2391          * add_link() will handle the nlink inc, so new nlink must be correct
2392          */
2393         list_for_each_entry(backref, &rec->backrefs, list) {
2394                 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2395                                      backref->name, backref->namelen,
2396                                      backref->filetype, &backref->index, 1);
2397                 if (ret < 0)
2398                         goto out;
2399         }
2400 out:
2401         btrfs_release_path(path);
2402         return ret;
2403 }
2404
2405 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2406                                struct btrfs_root *root,
2407                                struct btrfs_path *path,
2408                                struct inode_record *rec)
2409 {
2410         char *dir_name = "lost+found";
2411         char namebuf[BTRFS_NAME_LEN] = {0};
2412         u64 lost_found_ino;
2413         u32 mode = 0700;
2414         u8 type = 0;
2415         int namelen = 0;
2416         int name_recovered = 0;
2417         int type_recovered = 0;
2418         int ret = 0;
2419
2420         /*
2421          * Get file name and type first before these invalid inode ref
2422          * are deleted by remove_all_invalid_backref()
2423          */
2424         name_recovered = !find_file_name(rec, namebuf, &namelen);
2425         type_recovered = !find_file_type(rec, &type);
2426
2427         if (!name_recovered) {
2428                 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2429                        rec->ino, rec->ino);
2430                 namelen = count_digits(rec->ino);
2431                 sprintf(namebuf, "%llu", rec->ino);
2432                 name_recovered = 1;
2433         }
2434         if (!type_recovered) {
2435                 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2436                        rec->ino);
2437                 type = BTRFS_FT_REG_FILE;
2438                 type_recovered = 1;
2439         }
2440
2441         ret = reset_nlink(trans, root, path, rec);
2442         if (ret < 0) {
2443                 fprintf(stderr,
2444                         "Failed to reset nlink for inode %llu: %s\n",
2445                         rec->ino, strerror(-ret));
2446                 goto out;
2447         }
2448
2449         if (rec->found_link == 0) {
2450                 lost_found_ino = root->highest_inode;
2451                 if (lost_found_ino >= BTRFS_LAST_FREE_OBJECTID) {
2452                         ret = -EOVERFLOW;
2453                         goto out;
2454                 }
2455                 lost_found_ino++;
2456                 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2457                                   BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2458                                   mode);
2459                 if (ret < 0) {
2460                         fprintf(stderr, "Failed to create '%s' dir: %s\n",
2461                                 dir_name, strerror(-ret));
2462                         goto out;
2463                 }
2464                 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2465                                      namebuf, namelen, type, NULL, 1);
2466                 /*
2467                  * Add ".INO" suffix several times to handle case where
2468                  * "FILENAME.INO" is already taken by another file.
2469                  */
2470                 while (ret == -EEXIST) {
2471                         /*
2472                          * Conflicting file name, add ".INO" as suffix * +1 for '.'
2473                          */
2474                         if (namelen + count_digits(rec->ino) + 1 >
2475                             BTRFS_NAME_LEN) {
2476                                 ret = -EFBIG;
2477                                 goto out;
2478                         }
2479                         snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2480                                  ".%llu", rec->ino);
2481                         namelen += count_digits(rec->ino) + 1;
2482                         ret = btrfs_add_link(trans, root, rec->ino,
2483                                              lost_found_ino, namebuf,
2484                                              namelen, type, NULL, 1);
2485                 }
2486                 if (ret < 0) {
2487                         fprintf(stderr,
2488                                 "Failed to link the inode %llu to %s dir: %s\n",
2489                                 rec->ino, dir_name, strerror(-ret));
2490                         goto out;
2491                 }
2492                 /*
2493                  * Just increase the found_link, don't actually add the
2494                  * backref. This will make things easier and this inode
2495                  * record will be freed after the repair is done.
2496                  * So fsck will not report problem about this inode.
2497                  */
2498                 rec->found_link++;
2499                 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
2500                        namelen, namebuf, dir_name);
2501         }
2502         printf("Fixed the nlink of inode %llu\n", rec->ino);
2503 out:
2504         /*
2505          * Clear the flag anyway, or we will loop forever for the same inode
2506          * as it will not be removed from the bad inode list and the dead loop
2507          * happens.
2508          */
2509         rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
2510         btrfs_release_path(path);
2511         return ret;
2512 }
2513
2514 /*
2515  * Check if there is any normal(reg or prealloc) file extent for given
2516  * ino.
2517  * This is used to determine the file type when neither its dir_index/item or
2518  * inode_item exists.
2519  *
2520  * This will *NOT* report error, if any error happens, just consider it does
2521  * not have any normal file extent.
2522  */
2523 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
2524 {
2525         struct btrfs_path *path;
2526         struct btrfs_key key;
2527         struct btrfs_key found_key;
2528         struct btrfs_file_extent_item *fi;
2529         u8 type;
2530         int ret = 0;
2531
2532         path = btrfs_alloc_path();
2533         if (!path)
2534                 goto out;
2535         key.objectid = ino;
2536         key.type = BTRFS_EXTENT_DATA_KEY;
2537         key.offset = 0;
2538
2539         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
2540         if (ret < 0) {
2541                 ret = 0;
2542                 goto out;
2543         }
2544         if (ret && path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
2545                 ret = btrfs_next_leaf(root, path);
2546                 if (ret) {
2547                         ret = 0;
2548                         goto out;
2549                 }
2550         }
2551         while (1) {
2552                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2553                                       path->slots[0]);
2554                 if (found_key.objectid != ino ||
2555                     found_key.type != BTRFS_EXTENT_DATA_KEY)
2556                         break;
2557                 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
2558                                     struct btrfs_file_extent_item);
2559                 type = btrfs_file_extent_type(path->nodes[0], fi);
2560                 if (type != BTRFS_FILE_EXTENT_INLINE) {
2561                         ret = 1;
2562                         goto out;
2563                 }
2564         }
2565 out:
2566         btrfs_free_path(path);
2567         return ret;
2568 }
2569
2570 static u32 btrfs_type_to_imode(u8 type)
2571 {
2572         static u32 imode_by_btrfs_type[] = {
2573                 [BTRFS_FT_REG_FILE]     = S_IFREG,
2574                 [BTRFS_FT_DIR]          = S_IFDIR,
2575                 [BTRFS_FT_CHRDEV]       = S_IFCHR,
2576                 [BTRFS_FT_BLKDEV]       = S_IFBLK,
2577                 [BTRFS_FT_FIFO]         = S_IFIFO,
2578                 [BTRFS_FT_SOCK]         = S_IFSOCK,
2579                 [BTRFS_FT_SYMLINK]      = S_IFLNK,
2580         };
2581
2582         return imode_by_btrfs_type[(type)];
2583 }
2584
2585 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
2586                                 struct btrfs_root *root,
2587                                 struct btrfs_path *path,
2588                                 struct inode_record *rec)
2589 {
2590         u8 filetype;
2591         u32 mode = 0700;
2592         int type_recovered = 0;
2593         int ret = 0;
2594
2595         printf("Trying to rebuild inode:%llu\n", rec->ino);
2596
2597         type_recovered = !find_file_type(rec, &filetype);
2598
2599         /*
2600          * Try to determine inode type if type not found.
2601          *
2602          * For found regular file extent, it must be FILE.
2603          * For found dir_item/index, it must be DIR.
2604          *
2605          * For undetermined one, use FILE as fallback.
2606          *
2607          * TODO:
2608          * 1. If found backref(inode_index/item is already handled) to it,
2609          *    it must be DIR.
2610          *    Need new inode-inode ref structure to allow search for that.
2611          */
2612         if (!type_recovered) {
2613                 if (rec->found_file_extent &&
2614                     find_normal_file_extent(root, rec->ino)) {
2615                         type_recovered = 1;
2616                         filetype = BTRFS_FT_REG_FILE;
2617                 } else if (rec->found_dir_item) {
2618                         type_recovered = 1;
2619                         filetype = BTRFS_FT_DIR;
2620                 } else if (!list_empty(&rec->orphan_extents)) {
2621                         type_recovered = 1;
2622                         filetype = BTRFS_FT_REG_FILE;
2623                 } else{
2624                         printf("Can't determint the filetype for inode %llu, assume it is a normal file\n",
2625                                rec->ino);
2626                         type_recovered = 1;
2627                         filetype = BTRFS_FT_REG_FILE;
2628                 }
2629         }
2630
2631         ret = btrfs_new_inode(trans, root, rec->ino,
2632                               mode | btrfs_type_to_imode(filetype));
2633         if (ret < 0)
2634                 goto out;
2635
2636         /*
2637          * Here inode rebuild is done, we only rebuild the inode item,
2638          * don't repair the nlink(like move to lost+found).
2639          * That is the job of nlink repair.
2640          *
2641          * We just fill the record and return
2642          */
2643         rec->found_dir_item = 1;
2644         rec->imode = mode | btrfs_type_to_imode(filetype);
2645         rec->nlink = 0;
2646         rec->errors &= ~I_ERR_NO_INODE_ITEM;
2647         /* Ensure the inode_nlinks repair function will be called */
2648         rec->errors |= I_ERR_LINK_COUNT_WRONG;
2649 out:
2650         return ret;
2651 }
2652
2653 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
2654                                       struct btrfs_root *root,
2655                                       struct btrfs_path *path,
2656                                       struct inode_record *rec)
2657 {
2658         struct orphan_data_extent *orphan;
2659         struct orphan_data_extent *tmp;
2660         int ret = 0;
2661
2662         list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
2663                 /*
2664                  * Check for conflicting file extents
2665                  *
2666                  * Here we don't know whether the extents is compressed or not,
2667                  * so we can only assume it not compressed nor data offset,
2668                  * and use its disk_len as extent length.
2669                  */
2670                 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
2671                                        orphan->offset, orphan->disk_len, 0);
2672                 btrfs_release_path(path);
2673                 if (ret < 0)
2674                         goto out;
2675                 if (!ret) {
2676                         fprintf(stderr,
2677                                 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
2678                                 orphan->disk_bytenr, orphan->disk_len);
2679                         ret = btrfs_free_extent(trans,
2680                                         root->fs_info->extent_root,
2681                                         orphan->disk_bytenr, orphan->disk_len,
2682                                         0, root->objectid, orphan->objectid,
2683                                         orphan->offset);
2684                         if (ret < 0)
2685                                 goto out;
2686                 }
2687                 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
2688                                 orphan->offset, orphan->disk_bytenr,
2689                                 orphan->disk_len, orphan->disk_len);
2690                 if (ret < 0)
2691                         goto out;
2692
2693                 /* Update file size info */
2694                 rec->found_size += orphan->disk_len;
2695                 if (rec->found_size == rec->nbytes)
2696                         rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2697
2698                 /* Update the file extent hole info too */
2699                 ret = del_file_extent_hole(&rec->holes, orphan->offset,
2700                                            orphan->disk_len);
2701                 if (ret < 0)
2702                         goto out;
2703                 if (RB_EMPTY_ROOT(&rec->holes))
2704                         rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
2705
2706                 list_del(&orphan->list);
2707                 free(orphan);
2708         }
2709         rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
2710 out:
2711         return ret;
2712 }
2713
2714 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
2715                                         struct btrfs_root *root,
2716                                         struct btrfs_path *path,
2717                                         struct inode_record *rec)
2718 {
2719         struct rb_node *node;
2720         struct file_extent_hole *hole;
2721         int found = 0;
2722         int ret = 0;
2723
2724         node = rb_first(&rec->holes);
2725
2726         while (node) {
2727                 found = 1;
2728                 hole = rb_entry(node, struct file_extent_hole, node);
2729                 ret = btrfs_punch_hole(trans, root, rec->ino,
2730                                        hole->start, hole->len);
2731                 if (ret < 0)
2732                         goto out;
2733                 ret = del_file_extent_hole(&rec->holes, hole->start,
2734                                            hole->len);
2735                 if (ret < 0)
2736                         goto out;
2737                 if (RB_EMPTY_ROOT(&rec->holes))
2738                         rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
2739                 node = rb_first(&rec->holes);
2740         }
2741         /* special case for a file losing all its file extent */
2742         if (!found) {
2743                 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
2744                                        round_up(rec->isize, root->sectorsize));
2745                 if (ret < 0)
2746                         goto out;
2747         }
2748         printf("Fixed discount file extents for inode: %llu in root: %llu\n",
2749                rec->ino, root->objectid);
2750 out:
2751         return ret;
2752 }
2753
2754 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
2755 {
2756         struct btrfs_trans_handle *trans;
2757         struct btrfs_path *path;
2758         int ret = 0;
2759
2760         if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
2761                              I_ERR_NO_ORPHAN_ITEM |
2762                              I_ERR_LINK_COUNT_WRONG |
2763                              I_ERR_NO_INODE_ITEM |
2764                              I_ERR_FILE_EXTENT_ORPHAN |
2765                              I_ERR_FILE_EXTENT_DISCOUNT|
2766                              I_ERR_FILE_NBYTES_WRONG)))
2767                 return rec->errors;
2768
2769         path = btrfs_alloc_path();
2770         if (!path)
2771                 return -ENOMEM;
2772
2773         /*
2774          * For nlink repair, it may create a dir and add link, so
2775          * 2 for parent(256)'s dir_index and dir_item
2776          * 2 for lost+found dir's inode_item and inode_ref
2777          * 1 for the new inode_ref of the file
2778          * 2 for lost+found dir's dir_index and dir_item for the file
2779          */
2780         trans = btrfs_start_transaction(root, 7);
2781         if (IS_ERR(trans)) {
2782                 btrfs_free_path(path);
2783                 return PTR_ERR(trans);
2784         }
2785
2786         if (rec->errors & I_ERR_NO_INODE_ITEM)
2787                 ret = repair_inode_no_item(trans, root, path, rec);
2788         if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
2789                 ret = repair_inode_orphan_extent(trans, root, path, rec);
2790         if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
2791                 ret = repair_inode_discount_extent(trans, root, path, rec);
2792         if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
2793                 ret = repair_inode_isize(trans, root, path, rec);
2794         if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
2795                 ret = repair_inode_orphan_item(trans, root, path, rec);
2796         if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
2797                 ret = repair_inode_nlinks(trans, root, path, rec);
2798         if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
2799                 ret = repair_inode_nbytes(trans, root, path, rec);
2800         btrfs_commit_transaction(trans, root);
2801         btrfs_free_path(path);
2802         return ret;
2803 }
2804
2805 static int check_inode_recs(struct btrfs_root *root,
2806                             struct cache_tree *inode_cache)
2807 {
2808         struct cache_extent *cache;
2809         struct ptr_node *node;
2810         struct inode_record *rec;
2811         struct inode_backref *backref;
2812         int stage = 0;
2813         int ret = 0;
2814         int err = 0;
2815         u64 error = 0;
2816         u64 root_dirid = btrfs_root_dirid(&root->root_item);
2817
2818         if (btrfs_root_refs(&root->root_item) == 0) {
2819                 if (!cache_tree_empty(inode_cache))
2820                         fprintf(stderr, "warning line %d\n", __LINE__);
2821                 return 0;
2822         }
2823
2824         /*
2825          * We need to record the highest inode number for later 'lost+found'
2826          * dir creation.
2827          * We must select a ino not used/refered by any existing inode, or
2828          * 'lost+found' ino may be a missing ino in a corrupted leaf,
2829          * this may cause 'lost+found' dir has wrong nlinks.
2830          */
2831         cache = last_cache_extent(inode_cache);
2832         if (cache) {
2833                 node = container_of(cache, struct ptr_node, cache);
2834                 rec = node->data;
2835                 if (rec->ino > root->highest_inode)
2836                         root->highest_inode = rec->ino;
2837         }
2838
2839         /*
2840          * We need to repair backrefs first because we could change some of the
2841          * errors in the inode recs.
2842          *
2843          * We also need to go through and delete invalid backrefs first and then
2844          * add the correct ones second.  We do this because we may get EEXIST
2845          * when adding back the correct index because we hadn't yet deleted the
2846          * invalid index.
2847          *
2848          * For example, if we were missing a dir index then the directories
2849          * isize would be wrong, so if we fixed the isize to what we thought it
2850          * would be and then fixed the backref we'd still have a invalid fs, so
2851          * we need to add back the dir index and then check to see if the isize
2852          * is still wrong.
2853          */
2854         while (stage < 3) {
2855                 stage++;
2856                 if (stage == 3 && !err)
2857                         break;
2858
2859                 cache = search_cache_extent(inode_cache, 0);
2860                 while (repair && cache) {
2861                         node = container_of(cache, struct ptr_node, cache);
2862                         rec = node->data;
2863                         cache = next_cache_extent(cache);
2864
2865                         /* Need to free everything up and rescan */
2866                         if (stage == 3) {
2867                                 remove_cache_extent(inode_cache, &node->cache);
2868                                 free(node);
2869                                 free_inode_rec(rec);
2870                                 continue;
2871                         }
2872
2873                         if (list_empty(&rec->backrefs))
2874                                 continue;
2875
2876                         ret = repair_inode_backrefs(root, rec, inode_cache,
2877                                                     stage == 1);
2878                         if (ret < 0) {
2879                                 err = ret;
2880                                 stage = 2;
2881                                 break;
2882                         } if (ret > 0) {
2883                                 err = -EAGAIN;
2884                         }
2885                 }
2886         }
2887         if (err)
2888                 return err;
2889
2890         rec = get_inode_rec(inode_cache, root_dirid, 0);
2891         if (rec) {
2892                 ret = check_root_dir(rec);
2893                 if (ret) {
2894                         fprintf(stderr, "root %llu root dir %llu error\n",
2895                                 (unsigned long long)root->root_key.objectid,
2896                                 (unsigned long long)root_dirid);
2897                         print_inode_error(root, rec);
2898                         error++;
2899                 }
2900         } else {
2901                 if (repair) {
2902                         struct btrfs_trans_handle *trans;
2903
2904                         trans = btrfs_start_transaction(root, 1);
2905                         if (IS_ERR(trans)) {
2906                                 err = PTR_ERR(trans);
2907                                 return err;
2908                         }
2909
2910                         fprintf(stderr,
2911                                 "root %llu missing its root dir, recreating\n",
2912                                 (unsigned long long)root->objectid);
2913
2914                         ret = btrfs_make_root_dir(trans, root, root_dirid);
2915                         BUG_ON(ret);
2916
2917                         btrfs_commit_transaction(trans, root);
2918                         return -EAGAIN;
2919                 }
2920
2921                 fprintf(stderr, "root %llu root dir %llu not found\n",
2922                         (unsigned long long)root->root_key.objectid,
2923                         (unsigned long long)root_dirid);
2924         }
2925
2926         while (1) {
2927                 cache = search_cache_extent(inode_cache, 0);
2928                 if (!cache)
2929                         break;
2930                 node = container_of(cache, struct ptr_node, cache);
2931                 rec = node->data;
2932                 remove_cache_extent(inode_cache, &node->cache);
2933                 free(node);
2934                 if (rec->ino == root_dirid ||
2935                     rec->ino == BTRFS_ORPHAN_OBJECTID) {
2936                         free_inode_rec(rec);
2937                         continue;
2938                 }
2939
2940                 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
2941                         ret = check_orphan_item(root, rec->ino);
2942                         if (ret == 0)
2943                                 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2944                         if (can_free_inode_rec(rec)) {
2945                                 free_inode_rec(rec);
2946                                 continue;
2947                         }
2948                 }
2949
2950                 if (!rec->found_inode_item)
2951                         rec->errors |= I_ERR_NO_INODE_ITEM;
2952                 if (rec->found_link != rec->nlink)
2953                         rec->errors |= I_ERR_LINK_COUNT_WRONG;
2954                 if (repair) {
2955                         ret = try_repair_inode(root, rec);
2956                         if (ret == 0 && can_free_inode_rec(rec)) {
2957                                 free_inode_rec(rec);
2958                                 continue;
2959                         }
2960                         ret = 0;
2961                 }
2962
2963                 if (!(repair && ret == 0))
2964                         error++;
2965                 print_inode_error(root, rec);
2966                 list_for_each_entry(backref, &rec->backrefs, list) {
2967                         if (!backref->found_dir_item)
2968                                 backref->errors |= REF_ERR_NO_DIR_ITEM;
2969                         if (!backref->found_dir_index)
2970                                 backref->errors |= REF_ERR_NO_DIR_INDEX;
2971                         if (!backref->found_inode_ref)
2972                                 backref->errors |= REF_ERR_NO_INODE_REF;
2973                         fprintf(stderr, "\tunresolved ref dir %llu index %llu"
2974                                 " namelen %u name %s filetype %d errors %x",
2975                                 (unsigned long long)backref->dir,
2976                                 (unsigned long long)backref->index,
2977                                 backref->namelen, backref->name,
2978                                 backref->filetype, backref->errors);
2979                         print_ref_error(backref->errors);
2980                 }
2981                 free_inode_rec(rec);
2982         }
2983         return (error > 0) ? -1 : 0;
2984 }
2985
2986 static struct root_record *get_root_rec(struct cache_tree *root_cache,
2987                                         u64 objectid)
2988 {
2989         struct cache_extent *cache;
2990         struct root_record *rec = NULL;
2991         int ret;
2992
2993         cache = lookup_cache_extent(root_cache, objectid, 1);
2994         if (cache) {
2995                 rec = container_of(cache, struct root_record, cache);
2996         } else {
2997                 rec = calloc(1, sizeof(*rec));
2998                 rec->objectid = objectid;
2999                 INIT_LIST_HEAD(&rec->backrefs);
3000                 rec->cache.start = objectid;
3001                 rec->cache.size = 1;
3002
3003                 ret = insert_cache_extent(root_cache, &rec->cache);
3004                 BUG_ON(ret);
3005         }
3006         return rec;
3007 }
3008
3009 static struct root_backref *get_root_backref(struct root_record *rec,
3010                                              u64 ref_root, u64 dir, u64 index,
3011                                              const char *name, int namelen)
3012 {
3013         struct root_backref *backref;
3014
3015         list_for_each_entry(backref, &rec->backrefs, list) {
3016                 if (backref->ref_root != ref_root || backref->dir != dir ||
3017                     backref->namelen != namelen)
3018                         continue;
3019                 if (memcmp(name, backref->name, namelen))
3020                         continue;
3021                 return backref;
3022         }
3023
3024         backref = calloc(1, 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 = calloc(1, btrfs_chunk_record_size(num_stripes));
4896         if (!rec) {
4897                 fprintf(stderr, "memory allocation failed\n");
4898                 exit(-1);
4899         }
4900
4901         INIT_LIST_HEAD(&rec->list);
4902         INIT_LIST_HEAD(&rec->dextents);
4903         rec->bg_rec = NULL;
4904
4905         rec->cache.start = key->offset;
4906         rec->cache.size = btrfs_chunk_length(leaf, ptr);
4907
4908         rec->generation = btrfs_header_generation(leaf);
4909
4910         rec->objectid = key->objectid;
4911         rec->type = key->type;
4912         rec->offset = key->offset;
4913
4914         rec->length = rec->cache.size;
4915         rec->owner = btrfs_chunk_owner(leaf, ptr);
4916         rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
4917         rec->type_flags = btrfs_chunk_type(leaf, ptr);
4918         rec->io_width = btrfs_chunk_io_width(leaf, ptr);
4919         rec->io_align = btrfs_chunk_io_align(leaf, ptr);
4920         rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
4921         rec->num_stripes = num_stripes;
4922         rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
4923
4924         for (i = 0; i < rec->num_stripes; ++i) {
4925                 rec->stripes[i].devid =
4926                         btrfs_stripe_devid_nr(leaf, ptr, i);
4927                 rec->stripes[i].offset =
4928                         btrfs_stripe_offset_nr(leaf, ptr, i);
4929                 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
4930                                 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
4931                                 BTRFS_UUID_SIZE);
4932         }
4933
4934         return rec;
4935 }
4936
4937 static int process_chunk_item(struct cache_tree *chunk_cache,
4938                               struct btrfs_key *key, struct extent_buffer *eb,
4939                               int slot)
4940 {
4941         struct chunk_record *rec;
4942         int ret = 0;
4943
4944         rec = btrfs_new_chunk_record(eb, key, slot);
4945         ret = insert_cache_extent(chunk_cache, &rec->cache);
4946         if (ret) {
4947                 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
4948                         rec->offset, rec->length);
4949                 free(rec);
4950         }
4951
4952         return ret;
4953 }
4954
4955 static int process_device_item(struct rb_root *dev_cache,
4956                 struct btrfs_key *key, struct extent_buffer *eb, int slot)
4957 {
4958         struct btrfs_dev_item *ptr;
4959         struct device_record *rec;
4960         int ret = 0;
4961
4962         ptr = btrfs_item_ptr(eb,
4963                 slot, struct btrfs_dev_item);
4964
4965         rec = malloc(sizeof(*rec));
4966         if (!rec) {
4967                 fprintf(stderr, "memory allocation failed\n");
4968                 return -ENOMEM;
4969         }
4970
4971         rec->devid = key->offset;
4972         rec->generation = btrfs_header_generation(eb);
4973
4974         rec->objectid = key->objectid;
4975         rec->type = key->type;
4976         rec->offset = key->offset;
4977
4978         rec->devid = btrfs_device_id(eb, ptr);
4979         rec->total_byte = btrfs_device_total_bytes(eb, ptr);
4980         rec->byte_used = btrfs_device_bytes_used(eb, ptr);
4981
4982         ret = rb_insert(dev_cache, &rec->node, device_record_compare);
4983         if (ret) {
4984                 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
4985                 free(rec);
4986         }
4987
4988         return ret;
4989 }
4990
4991 struct block_group_record *
4992 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
4993                              int slot)
4994 {
4995         struct btrfs_block_group_item *ptr;
4996         struct block_group_record *rec;
4997
4998         rec = calloc(1, sizeof(*rec));
4999         if (!rec) {
5000                 fprintf(stderr, "memory allocation failed\n");
5001                 exit(-1);
5002         }
5003
5004         rec->cache.start = key->objectid;
5005         rec->cache.size = key->offset;
5006
5007         rec->generation = btrfs_header_generation(leaf);
5008
5009         rec->objectid = key->objectid;
5010         rec->type = key->type;
5011         rec->offset = key->offset;
5012
5013         ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
5014         rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
5015
5016         INIT_LIST_HEAD(&rec->list);
5017
5018         return rec;
5019 }
5020
5021 static int process_block_group_item(struct block_group_tree *block_group_cache,
5022                                     struct btrfs_key *key,
5023                                     struct extent_buffer *eb, int slot)
5024 {
5025         struct block_group_record *rec;
5026         int ret = 0;
5027
5028         rec = btrfs_new_block_group_record(eb, key, slot);
5029         ret = insert_block_group_record(block_group_cache, rec);
5030         if (ret) {
5031                 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
5032                         rec->objectid, rec->offset);
5033                 free(rec);
5034         }
5035
5036         return ret;
5037 }
5038
5039 struct device_extent_record *
5040 btrfs_new_device_extent_record(struct extent_buffer *leaf,
5041                                struct btrfs_key *key, int slot)
5042 {
5043         struct device_extent_record *rec;
5044         struct btrfs_dev_extent *ptr;
5045
5046         rec = calloc(1, sizeof(*rec));
5047         if (!rec) {
5048                 fprintf(stderr, "memory allocation failed\n");
5049                 exit(-1);
5050         }
5051
5052         rec->cache.objectid = key->objectid;
5053         rec->cache.start = key->offset;
5054
5055         rec->generation = btrfs_header_generation(leaf);
5056
5057         rec->objectid = key->objectid;
5058         rec->type = key->type;
5059         rec->offset = key->offset;
5060
5061         ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
5062         rec->chunk_objecteid =
5063                 btrfs_dev_extent_chunk_objectid(leaf, ptr);
5064         rec->chunk_offset =
5065                 btrfs_dev_extent_chunk_offset(leaf, ptr);
5066         rec->length = btrfs_dev_extent_length(leaf, ptr);
5067         rec->cache.size = rec->length;
5068
5069         INIT_LIST_HEAD(&rec->chunk_list);
5070         INIT_LIST_HEAD(&rec->device_list);
5071
5072         return rec;
5073 }
5074
5075 static int
5076 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
5077                            struct btrfs_key *key, struct extent_buffer *eb,
5078                            int slot)
5079 {
5080         struct device_extent_record *rec;
5081         int ret;
5082
5083         rec = btrfs_new_device_extent_record(eb, key, slot);
5084         ret = insert_device_extent_record(dev_extent_cache, rec);
5085         if (ret) {
5086                 fprintf(stderr,
5087                         "Device extent[%llu, %llu, %llu] existed.\n",
5088                         rec->objectid, rec->offset, rec->length);
5089                 free(rec);
5090         }
5091
5092         return ret;
5093 }
5094
5095 static int process_extent_item(struct btrfs_root *root,
5096                                struct cache_tree *extent_cache,
5097                                struct extent_buffer *eb, int slot)
5098 {
5099         struct btrfs_extent_item *ei;
5100         struct btrfs_extent_inline_ref *iref;
5101         struct btrfs_extent_data_ref *dref;
5102         struct btrfs_shared_data_ref *sref;
5103         struct btrfs_key key;
5104         unsigned long end;
5105         unsigned long ptr;
5106         int type;
5107         u32 item_size = btrfs_item_size_nr(eb, slot);
5108         u64 refs = 0;
5109         u64 offset;
5110         u64 num_bytes;
5111         int metadata = 0;
5112
5113         btrfs_item_key_to_cpu(eb, &key, slot);
5114
5115         if (key.type == BTRFS_METADATA_ITEM_KEY) {
5116                 metadata = 1;
5117                 num_bytes = root->leafsize;
5118         } else {
5119                 num_bytes = key.offset;
5120         }
5121
5122         if (item_size < sizeof(*ei)) {
5123 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
5124                 struct btrfs_extent_item_v0 *ei0;
5125                 BUG_ON(item_size != sizeof(*ei0));
5126                 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
5127                 refs = btrfs_extent_refs_v0(eb, ei0);
5128 #else
5129                 BUG();
5130 #endif
5131                 return add_extent_rec(extent_cache, NULL, 0, key.objectid,
5132                                       num_bytes, refs, 0, 0, 0, metadata, 1,
5133                                       num_bytes);
5134         }
5135
5136         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
5137         refs = btrfs_extent_refs(eb, ei);
5138         if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
5139                 metadata = 1;
5140         else
5141                 metadata = 0;
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 fail:
6435         btrfs_release_path(path);
6436         return ret;
6437 }
6438
6439 struct extent_entry {
6440         u64 bytenr;
6441         u64 bytes;
6442         int count;
6443         int broken;
6444         struct list_head list;
6445 };
6446
6447 static struct extent_entry *find_entry(struct list_head *entries,
6448                                        u64 bytenr, u64 bytes)
6449 {
6450         struct extent_entry *entry = NULL;
6451
6452         list_for_each_entry(entry, entries, list) {
6453                 if (entry->bytenr == bytenr && entry->bytes == bytes)
6454                         return entry;
6455         }
6456
6457         return NULL;
6458 }
6459
6460 static struct extent_entry *find_most_right_entry(struct list_head *entries)
6461 {
6462         struct extent_entry *entry, *best = NULL, *prev = NULL;
6463
6464         list_for_each_entry(entry, entries, list) {
6465                 if (!prev) {
6466                         prev = entry;
6467                         continue;
6468                 }
6469
6470                 /*
6471                  * If there are as many broken entries as entries then we know
6472                  * not to trust this particular entry.
6473                  */
6474                 if (entry->broken == entry->count)
6475                         continue;
6476
6477                 /*
6478                  * If our current entry == best then we can't be sure our best
6479                  * is really the best, so we need to keep searching.
6480                  */
6481                 if (best && best->count == entry->count) {
6482                         prev = entry;
6483                         best = NULL;
6484                         continue;
6485                 }
6486
6487                 /* Prev == entry, not good enough, have to keep searching */
6488                 if (!prev->broken && prev->count == entry->count)
6489                         continue;
6490
6491                 if (!best)
6492                         best = (prev->count > entry->count) ? prev : entry;
6493                 else if (best->count < entry->count)
6494                         best = entry;
6495                 prev = entry;
6496         }
6497
6498         return best;
6499 }
6500
6501 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
6502                       struct data_backref *dback, struct extent_entry *entry)
6503 {
6504         struct btrfs_trans_handle *trans;
6505         struct btrfs_root *root;
6506         struct btrfs_file_extent_item *fi;
6507         struct extent_buffer *leaf;
6508         struct btrfs_key key;
6509         u64 bytenr, bytes;
6510         int ret, err;
6511
6512         key.objectid = dback->root;
6513         key.type = BTRFS_ROOT_ITEM_KEY;
6514         key.offset = (u64)-1;
6515         root = btrfs_read_fs_root(info, &key);
6516         if (IS_ERR(root)) {
6517                 fprintf(stderr, "Couldn't find root for our ref\n");
6518                 return -EINVAL;
6519         }
6520
6521         /*
6522          * The backref points to the original offset of the extent if it was
6523          * split, so we need to search down to the offset we have and then walk
6524          * forward until we find the backref we're looking for.
6525          */
6526         key.objectid = dback->owner;
6527         key.type = BTRFS_EXTENT_DATA_KEY;
6528         key.offset = dback->offset;
6529         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6530         if (ret < 0) {
6531                 fprintf(stderr, "Error looking up ref %d\n", ret);
6532                 return ret;
6533         }
6534
6535         while (1) {
6536                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
6537                         ret = btrfs_next_leaf(root, path);
6538                         if (ret) {
6539                                 fprintf(stderr, "Couldn't find our ref, next\n");
6540                                 return -EINVAL;
6541                         }
6542                 }
6543                 leaf = path->nodes[0];
6544                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
6545                 if (key.objectid != dback->owner ||
6546                     key.type != BTRFS_EXTENT_DATA_KEY) {
6547                         fprintf(stderr, "Couldn't find our ref, search\n");
6548                         return -EINVAL;
6549                 }
6550                 fi = btrfs_item_ptr(leaf, path->slots[0],
6551                                     struct btrfs_file_extent_item);
6552                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
6553                 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
6554
6555                 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
6556                         break;
6557                 path->slots[0]++;
6558         }
6559
6560         btrfs_release_path(path);
6561
6562         trans = btrfs_start_transaction(root, 1);
6563         if (IS_ERR(trans))
6564                 return PTR_ERR(trans);
6565
6566         /*
6567          * Ok we have the key of the file extent we want to fix, now we can cow
6568          * down to the thing and fix it.
6569          */
6570         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
6571         if (ret < 0) {
6572                 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
6573                         key.objectid, key.type, key.offset, ret);
6574                 goto out;
6575         }
6576         if (ret > 0) {
6577                 fprintf(stderr, "Well that's odd, we just found this key "
6578                         "[%Lu, %u, %Lu]\n", key.objectid, key.type,
6579                         key.offset);
6580                 ret = -EINVAL;
6581                 goto out;
6582         }
6583         leaf = path->nodes[0];
6584         fi = btrfs_item_ptr(leaf, path->slots[0],
6585                             struct btrfs_file_extent_item);
6586
6587         if (btrfs_file_extent_compression(leaf, fi) &&
6588             dback->disk_bytenr != entry->bytenr) {
6589                 fprintf(stderr, "Ref doesn't match the record start and is "
6590                         "compressed, please take a btrfs-image of this file "
6591                         "system and send it to a btrfs developer so they can "
6592                         "complete this functionality for bytenr %Lu\n",
6593                         dback->disk_bytenr);
6594                 ret = -EINVAL;
6595                 goto out;
6596         }
6597
6598         if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
6599                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6600         } else if (dback->disk_bytenr > entry->bytenr) {
6601                 u64 off_diff, offset;
6602
6603                 off_diff = dback->disk_bytenr - entry->bytenr;
6604                 offset = btrfs_file_extent_offset(leaf, fi);
6605                 if (dback->disk_bytenr + offset +
6606                     btrfs_file_extent_num_bytes(leaf, fi) >
6607                     entry->bytenr + entry->bytes) {
6608                         fprintf(stderr, "Ref is past the entry end, please "
6609                                 "take a btrfs-image of this file system and "
6610                                 "send it to a btrfs developer, ref %Lu\n",
6611                                 dback->disk_bytenr);
6612                         ret = -EINVAL;
6613                         goto out;
6614                 }
6615                 offset += off_diff;
6616                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6617                 btrfs_set_file_extent_offset(leaf, fi, offset);
6618         } else if (dback->disk_bytenr < entry->bytenr) {
6619                 u64 offset;
6620
6621                 offset = btrfs_file_extent_offset(leaf, fi);
6622                 if (dback->disk_bytenr + offset < entry->bytenr) {
6623                         fprintf(stderr, "Ref is before the entry start, please"
6624                                 " take a btrfs-image of this file system and "
6625                                 "send it to a btrfs developer, ref %Lu\n",
6626                                 dback->disk_bytenr);
6627                         ret = -EINVAL;
6628                         goto out;
6629                 }
6630
6631                 offset += dback->disk_bytenr;
6632                 offset -= entry->bytenr;
6633                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
6634                 btrfs_set_file_extent_offset(leaf, fi, offset);
6635         }
6636
6637         btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
6638
6639         /*
6640          * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
6641          * only do this if we aren't using compression, otherwise it's a
6642          * trickier case.
6643          */
6644         if (!btrfs_file_extent_compression(leaf, fi))
6645                 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
6646         else
6647                 printf("ram bytes may be wrong?\n");
6648         btrfs_mark_buffer_dirty(leaf);
6649 out:
6650         err = btrfs_commit_transaction(trans, root);
6651         btrfs_release_path(path);
6652         return ret ? ret : err;
6653 }
6654
6655 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
6656                            struct extent_record *rec)
6657 {
6658         struct extent_backref *back;
6659         struct data_backref *dback;
6660         struct extent_entry *entry, *best = NULL;
6661         LIST_HEAD(entries);
6662         int nr_entries = 0;
6663         int broken_entries = 0;
6664         int ret = 0;
6665         short mismatch = 0;
6666
6667         /*
6668          * Metadata is easy and the backrefs should always agree on bytenr and
6669          * size, if not we've got bigger issues.
6670          */
6671         if (rec->metadata)
6672                 return 0;
6673
6674         list_for_each_entry(back, &rec->backrefs, list) {
6675                 if (back->full_backref || !back->is_data)
6676                         continue;
6677
6678                 dback = (struct data_backref *)back;
6679
6680                 /*
6681                  * We only pay attention to backrefs that we found a real
6682                  * backref for.
6683                  */
6684                 if (dback->found_ref == 0)
6685                         continue;
6686
6687                 /*
6688                  * For now we only catch when the bytes don't match, not the
6689                  * bytenr.  We can easily do this at the same time, but I want
6690                  * to have a fs image to test on before we just add repair
6691                  * functionality willy-nilly so we know we won't screw up the
6692                  * repair.
6693                  */
6694
6695                 entry = find_entry(&entries, dback->disk_bytenr,
6696                                    dback->bytes);
6697                 if (!entry) {
6698                         entry = malloc(sizeof(struct extent_entry));
6699                         if (!entry) {
6700                                 ret = -ENOMEM;
6701                                 goto out;
6702                         }
6703                         memset(entry, 0, sizeof(*entry));
6704                         entry->bytenr = dback->disk_bytenr;
6705                         entry->bytes = dback->bytes;
6706                         list_add_tail(&entry->list, &entries);
6707                         nr_entries++;
6708                 }
6709
6710                 /*
6711                  * If we only have on entry we may think the entries agree when
6712                  * in reality they don't so we have to do some extra checking.
6713                  */
6714                 if (dback->disk_bytenr != rec->start ||
6715                     dback->bytes != rec->nr || back->broken)
6716                         mismatch = 1;
6717
6718                 if (back->broken) {
6719                         entry->broken++;
6720                         broken_entries++;
6721                 }
6722
6723                 entry->count++;
6724         }
6725
6726         /* Yay all the backrefs agree, carry on good sir */
6727         if (nr_entries <= 1 && !mismatch)
6728                 goto out;
6729
6730         fprintf(stderr, "attempting to repair backref discrepency for bytenr "
6731                 "%Lu\n", rec->start);
6732
6733         /*
6734          * First we want to see if the backrefs can agree amongst themselves who
6735          * is right, so figure out which one of the entries has the highest
6736          * count.
6737          */
6738         best = find_most_right_entry(&entries);
6739
6740         /*
6741          * Ok so we may have an even split between what the backrefs think, so
6742          * this is where we use the extent ref to see what it thinks.
6743          */
6744         if (!best) {
6745                 entry = find_entry(&entries, rec->start, rec->nr);
6746                 if (!entry && (!broken_entries || !rec->found_rec)) {
6747                         fprintf(stderr, "Backrefs don't agree with each other "
6748                                 "and extent record doesn't agree with anybody,"
6749                                 " so we can't fix bytenr %Lu bytes %Lu\n",
6750                                 rec->start, rec->nr);
6751                         ret = -EINVAL;
6752                         goto out;
6753                 } else if (!entry) {
6754                         /*
6755                          * Ok our backrefs were broken, we'll assume this is the
6756                          * correct value and add an entry for this range.
6757                          */
6758                         entry = malloc(sizeof(struct extent_entry));
6759                         if (!entry) {
6760                                 ret = -ENOMEM;
6761                                 goto out;
6762                         }
6763                         memset(entry, 0, sizeof(*entry));
6764                         entry->bytenr = rec->start;
6765                         entry->bytes = rec->nr;
6766                         list_add_tail(&entry->list, &entries);
6767                         nr_entries++;
6768                 }
6769                 entry->count++;
6770                 best = find_most_right_entry(&entries);
6771                 if (!best) {
6772                         fprintf(stderr, "Backrefs and extent record evenly "
6773                                 "split on who is right, this is going to "
6774                                 "require user input to fix bytenr %Lu bytes "
6775                                 "%Lu\n", rec->start, rec->nr);
6776                         ret = -EINVAL;
6777                         goto out;
6778                 }
6779         }
6780
6781         /*
6782          * I don't think this can happen currently as we'll abort() if we catch
6783          * this case higher up, but in case somebody removes that we still can't
6784          * deal with it properly here yet, so just bail out of that's the case.
6785          */
6786         if (best->bytenr != rec->start) {
6787                 fprintf(stderr, "Extent start and backref starts don't match, "
6788                         "please use btrfs-image on this file system and send "
6789                         "it to a btrfs developer so they can make fsck fix "
6790                         "this particular case.  bytenr is %Lu, bytes is %Lu\n",
6791                         rec->start, rec->nr);
6792                 ret = -EINVAL;
6793                 goto out;
6794         }
6795
6796         /*
6797          * Ok great we all agreed on an extent record, let's go find the real
6798          * references and fix up the ones that don't match.
6799          */
6800         list_for_each_entry(back, &rec->backrefs, list) {
6801                 if (back->full_backref || !back->is_data)
6802                         continue;
6803
6804                 dback = (struct data_backref *)back;
6805
6806                 /*
6807                  * Still ignoring backrefs that don't have a real ref attached
6808                  * to them.
6809                  */
6810                 if (dback->found_ref == 0)
6811                         continue;
6812
6813                 if (dback->bytes == best->bytes &&
6814                     dback->disk_bytenr == best->bytenr)
6815                         continue;
6816
6817                 ret = repair_ref(info, path, dback, best);
6818                 if (ret)
6819                         goto out;
6820         }
6821
6822         /*
6823          * Ok we messed with the actual refs, which means we need to drop our
6824          * entire cache and go back and rescan.  I know this is a huge pain and
6825          * adds a lot of extra work, but it's the only way to be safe.  Once all
6826          * the backrefs agree we may not need to do anything to the extent
6827          * record itself.
6828          */
6829         ret = -EAGAIN;
6830 out:
6831         while (!list_empty(&entries)) {
6832                 entry = list_entry(entries.next, struct extent_entry, list);
6833                 list_del_init(&entry->list);
6834                 free(entry);
6835         }
6836         return ret;
6837 }
6838
6839 static int process_duplicates(struct btrfs_root *root,
6840                               struct cache_tree *extent_cache,
6841                               struct extent_record *rec)
6842 {
6843         struct extent_record *good, *tmp;
6844         struct cache_extent *cache;
6845         int ret;
6846
6847         /*
6848          * If we found a extent record for this extent then return, or if we
6849          * have more than one duplicate we are likely going to need to delete
6850          * something.
6851          */
6852         if (rec->found_rec || rec->num_duplicates > 1)
6853                 return 0;
6854
6855         /* Shouldn't happen but just in case */
6856         BUG_ON(!rec->num_duplicates);
6857
6858         /*
6859          * So this happens if we end up with a backref that doesn't match the
6860          * actual extent entry.  So either the backref is bad or the extent
6861          * entry is bad.  Either way we want to have the extent_record actually
6862          * reflect what we found in the extent_tree, so we need to take the
6863          * duplicate out and use that as the extent_record since the only way we
6864          * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
6865          */
6866         remove_cache_extent(extent_cache, &rec->cache);
6867
6868         good = list_entry(rec->dups.next, struct extent_record, list);
6869         list_del_init(&good->list);
6870         INIT_LIST_HEAD(&good->backrefs);
6871         INIT_LIST_HEAD(&good->dups);
6872         good->cache.start = good->start;
6873         good->cache.size = good->nr;
6874         good->content_checked = 0;
6875         good->owner_ref_checked = 0;
6876         good->num_duplicates = 0;
6877         good->refs = rec->refs;
6878         list_splice_init(&rec->backrefs, &good->backrefs);
6879         while (1) {
6880                 cache = lookup_cache_extent(extent_cache, good->start,
6881                                             good->nr);
6882                 if (!cache)
6883                         break;
6884                 tmp = container_of(cache, struct extent_record, cache);
6885
6886                 /*
6887                  * If we find another overlapping extent and it's found_rec is
6888                  * set then it's a duplicate and we need to try and delete
6889                  * something.
6890                  */
6891                 if (tmp->found_rec || tmp->num_duplicates > 0) {
6892                         if (list_empty(&good->list))
6893                                 list_add_tail(&good->list,
6894                                               &duplicate_extents);
6895                         good->num_duplicates += tmp->num_duplicates + 1;
6896                         list_splice_init(&tmp->dups, &good->dups);
6897                         list_del_init(&tmp->list);
6898                         list_add_tail(&tmp->list, &good->dups);
6899                         remove_cache_extent(extent_cache, &tmp->cache);
6900                         continue;
6901                 }
6902
6903                 /*
6904                  * Ok we have another non extent item backed extent rec, so lets
6905                  * just add it to this extent and carry on like we did above.
6906                  */
6907                 good->refs += tmp->refs;
6908                 list_splice_init(&tmp->backrefs, &good->backrefs);
6909                 remove_cache_extent(extent_cache, &tmp->cache);
6910                 free(tmp);
6911         }
6912         ret = insert_cache_extent(extent_cache, &good->cache);
6913         BUG_ON(ret);
6914         free(rec);
6915         return good->num_duplicates ? 0 : 1;
6916 }
6917
6918 static int delete_duplicate_records(struct btrfs_root *root,
6919                                     struct extent_record *rec)
6920 {
6921         struct btrfs_trans_handle *trans;
6922         LIST_HEAD(delete_list);
6923         struct btrfs_path *path;
6924         struct extent_record *tmp, *good, *n;
6925         int nr_del = 0;
6926         int ret = 0, err;
6927         struct btrfs_key key;
6928
6929         path = btrfs_alloc_path();
6930         if (!path) {
6931                 ret = -ENOMEM;
6932                 goto out;
6933         }
6934
6935         good = rec;
6936         /* Find the record that covers all of the duplicates. */
6937         list_for_each_entry(tmp, &rec->dups, list) {
6938                 if (good->start < tmp->start)
6939                         continue;
6940                 if (good->nr > tmp->nr)
6941                         continue;
6942
6943                 if (tmp->start + tmp->nr < good->start + good->nr) {
6944                         fprintf(stderr, "Ok we have overlapping extents that "
6945                                 "aren't completely covered by eachother, this "
6946                                 "is going to require more careful thought.  "
6947                                 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
6948                                 tmp->start, tmp->nr, good->start, good->nr);
6949                         abort();
6950                 }
6951                 good = tmp;
6952         }
6953
6954         if (good != rec)
6955                 list_add_tail(&rec->list, &delete_list);
6956
6957         list_for_each_entry_safe(tmp, n, &rec->dups, list) {
6958                 if (tmp == good)
6959                         continue;
6960                 list_move_tail(&tmp->list, &delete_list);
6961         }
6962
6963         root = root->fs_info->extent_root;
6964         trans = btrfs_start_transaction(root, 1);
6965         if (IS_ERR(trans)) {
6966                 ret = PTR_ERR(trans);
6967                 goto out;
6968         }
6969
6970         list_for_each_entry(tmp, &delete_list, list) {
6971                 if (tmp->found_rec == 0)
6972                         continue;
6973                 key.objectid = tmp->start;
6974                 key.type = BTRFS_EXTENT_ITEM_KEY;
6975                 key.offset = tmp->nr;
6976
6977                 /* Shouldn't happen but just in case */
6978                 if (tmp->metadata) {
6979                         fprintf(stderr, "Well this shouldn't happen, extent "
6980                                 "record overlaps but is metadata? "
6981                                 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
6982                         abort();
6983                 }
6984
6985                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
6986                 if (ret) {
6987                         if (ret > 0)
6988                                 ret = -EINVAL;
6989                         break;
6990                 }
6991                 ret = btrfs_del_item(trans, root, path);
6992                 if (ret)
6993                         break;
6994                 btrfs_release_path(path);
6995                 nr_del++;
6996         }
6997         err = btrfs_commit_transaction(trans, root);
6998         if (err && !ret)
6999                 ret = err;
7000 out:
7001         while (!list_empty(&delete_list)) {
7002                 tmp = list_entry(delete_list.next, struct extent_record, list);
7003                 list_del_init(&tmp->list);
7004                 if (tmp == rec)
7005                         continue;
7006                 free(tmp);
7007         }
7008
7009         while (!list_empty(&rec->dups)) {
7010                 tmp = list_entry(rec->dups.next, struct extent_record, list);
7011                 list_del_init(&tmp->list);
7012                 free(tmp);
7013         }
7014
7015         btrfs_free_path(path);
7016
7017         if (!ret && !nr_del)
7018                 rec->num_duplicates = 0;
7019
7020         return ret ? ret : nr_del;
7021 }
7022
7023 static int find_possible_backrefs(struct btrfs_fs_info *info,
7024                                   struct btrfs_path *path,
7025                                   struct cache_tree *extent_cache,
7026                                   struct extent_record *rec)
7027 {
7028         struct btrfs_root *root;
7029         struct extent_backref *back;
7030         struct data_backref *dback;
7031         struct cache_extent *cache;
7032         struct btrfs_file_extent_item *fi;
7033         struct btrfs_key key;
7034         u64 bytenr, bytes;
7035         int ret;
7036
7037         list_for_each_entry(back, &rec->backrefs, list) {
7038                 /* Don't care about full backrefs (poor unloved backrefs) */
7039                 if (back->full_backref || !back->is_data)
7040                         continue;
7041
7042                 dback = (struct data_backref *)back;
7043
7044                 /* We found this one, we don't need to do a lookup */
7045                 if (dback->found_ref)
7046                         continue;
7047
7048                 key.objectid = dback->root;
7049                 key.type = BTRFS_ROOT_ITEM_KEY;
7050                 key.offset = (u64)-1;
7051
7052                 root = btrfs_read_fs_root(info, &key);
7053
7054                 /* No root, definitely a bad ref, skip */
7055                 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
7056                         continue;
7057                 /* Other err, exit */
7058                 if (IS_ERR(root))
7059                         return PTR_ERR(root);
7060
7061                 key.objectid = dback->owner;
7062                 key.type = BTRFS_EXTENT_DATA_KEY;
7063                 key.offset = dback->offset;
7064                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
7065                 if (ret) {
7066                         btrfs_release_path(path);
7067                         if (ret < 0)
7068                                 return ret;
7069                         /* Didn't find it, we can carry on */
7070                         ret = 0;
7071                         continue;
7072                 }
7073
7074                 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
7075                                     struct btrfs_file_extent_item);
7076                 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
7077                 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
7078                 btrfs_release_path(path);
7079                 cache = lookup_cache_extent(extent_cache, bytenr, 1);
7080                 if (cache) {
7081                         struct extent_record *tmp;
7082                         tmp = container_of(cache, struct extent_record, cache);
7083
7084                         /*
7085                          * If we found an extent record for the bytenr for this
7086                          * particular backref then we can't add it to our
7087                          * current extent record.  We only want to add backrefs
7088                          * that don't have a corresponding extent item in the
7089                          * extent tree since they likely belong to this record
7090                          * and we need to fix it if it doesn't match bytenrs.
7091                          */
7092                         if  (tmp->found_rec)
7093                                 continue;
7094                 }
7095
7096                 dback->found_ref += 1;
7097                 dback->disk_bytenr = bytenr;
7098                 dback->bytes = bytes;
7099
7100                 /*
7101                  * Set this so the verify backref code knows not to trust the
7102                  * values in this backref.
7103                  */
7104                 back->broken = 1;
7105         }
7106
7107         return 0;
7108 }
7109
7110 /*
7111  * Record orphan data ref into corresponding root.
7112  *
7113  * Return 0 if the extent item contains data ref and recorded.
7114  * Return 1 if the extent item contains no useful data ref
7115  *   On that case, it may contains only shared_dataref or metadata backref
7116  *   or the file extent exists(this should be handled by the extent bytenr
7117  *   recovery routine)
7118  * Return <0 if something goes wrong.
7119  */
7120 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
7121                                       struct extent_record *rec)
7122 {
7123         struct btrfs_key key;
7124         struct btrfs_root *dest_root;
7125         struct extent_backref *back;
7126         struct data_backref *dback;
7127         struct orphan_data_extent *orphan;
7128         struct btrfs_path *path;
7129         int recorded_data_ref = 0;
7130         int ret = 0;
7131
7132         if (rec->metadata)
7133                 return 1;
7134         path = btrfs_alloc_path();
7135         if (!path)
7136                 return -ENOMEM;
7137         list_for_each_entry(back, &rec->backrefs, list) {
7138                 if (back->full_backref || !back->is_data ||
7139                     !back->found_extent_tree)
7140                         continue;
7141                 dback = (struct data_backref *)back;
7142                 if (dback->found_ref)
7143                         continue;
7144                 key.objectid = dback->root;
7145                 key.type = BTRFS_ROOT_ITEM_KEY;
7146                 key.offset = (u64)-1;
7147
7148                 dest_root = btrfs_read_fs_root(fs_info, &key);
7149
7150                 /* For non-exist root we just skip it */
7151                 if (IS_ERR(dest_root) || !dest_root)
7152                         continue;
7153
7154                 key.objectid = dback->owner;
7155                 key.type = BTRFS_EXTENT_DATA_KEY;
7156                 key.offset = dback->offset;
7157
7158                 ret = btrfs_search_slot(NULL, dest_root, &key, path, 0, 0);
7159                 /*
7160                  * For ret < 0, it's OK since the fs-tree may be corrupted,
7161                  * we need to record it for inode/file extent rebuild.
7162                  * For ret > 0, we record it only for file extent rebuild.
7163                  * For ret == 0, the file extent exists but only bytenr
7164                  * mismatch, let the original bytenr fix routine to handle,
7165                  * don't record it.
7166                  */
7167                 if (ret == 0)
7168                         continue;
7169                 ret = 0;
7170                 orphan = malloc(sizeof(*orphan));
7171                 if (!orphan) {
7172                         ret = -ENOMEM;
7173                         goto out;
7174                 }
7175                 INIT_LIST_HEAD(&orphan->list);
7176                 orphan->root = dback->root;
7177                 orphan->objectid = dback->owner;
7178                 orphan->offset = dback->offset;
7179                 orphan->disk_bytenr = rec->cache.start;
7180                 orphan->disk_len = rec->cache.size;
7181                 list_add(&dest_root->orphan_data_extents, &orphan->list);
7182                 recorded_data_ref = 1;
7183         }
7184 out:
7185         btrfs_free_path(path);
7186         if (!ret)
7187                 return !recorded_data_ref;
7188         else
7189                 return ret;
7190 }
7191
7192 /*
7193  * when an incorrect extent item is found, this will delete
7194  * all of the existing entries for it and recreate them
7195  * based on what the tree scan found.
7196  */
7197 static int fixup_extent_refs(struct btrfs_fs_info *info,
7198                              struct cache_tree *extent_cache,
7199                              struct extent_record *rec)
7200 {
7201         struct btrfs_trans_handle *trans = NULL;
7202         int ret;
7203         struct btrfs_path *path;
7204         struct list_head *cur = rec->backrefs.next;
7205         struct cache_extent *cache;
7206         struct extent_backref *back;
7207         int allocated = 0;
7208         u64 flags = 0;
7209
7210         if (rec->flag_block_full_backref)
7211                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7212
7213         path = btrfs_alloc_path();
7214         if (!path)
7215                 return -ENOMEM;
7216
7217         if (rec->refs != rec->extent_item_refs && !rec->metadata) {
7218                 /*
7219                  * Sometimes the backrefs themselves are so broken they don't
7220                  * get attached to any meaningful rec, so first go back and
7221                  * check any of our backrefs that we couldn't find and throw
7222                  * them into the list if we find the backref so that
7223                  * verify_backrefs can figure out what to do.
7224                  */
7225                 ret = find_possible_backrefs(info, path, extent_cache, rec);
7226                 if (ret < 0)
7227                         goto out;
7228         }
7229
7230         /* step one, make sure all of the backrefs agree */
7231         ret = verify_backrefs(info, path, rec);
7232         if (ret < 0)
7233                 goto out;
7234
7235         trans = btrfs_start_transaction(info->extent_root, 1);
7236         if (IS_ERR(trans)) {
7237                 ret = PTR_ERR(trans);
7238                 goto out;
7239         }
7240
7241         /* step two, delete all the existing records */
7242         ret = delete_extent_records(trans, info->extent_root, path,
7243                                     rec->start, rec->max_size);
7244
7245         if (ret < 0)
7246                 goto out;
7247
7248         /* was this block corrupt?  If so, don't add references to it */
7249         cache = lookup_cache_extent(info->corrupt_blocks,
7250                                     rec->start, rec->max_size);
7251         if (cache) {
7252                 ret = 0;
7253                 goto out;
7254         }
7255
7256         /* step three, recreate all the refs we did find */
7257         while(cur != &rec->backrefs) {
7258                 back = list_entry(cur, struct extent_backref, list);
7259                 cur = cur->next;
7260
7261                 /*
7262                  * if we didn't find any references, don't create a
7263                  * new extent record
7264                  */
7265                 if (!back->found_ref)
7266                         continue;
7267
7268                 rec->bad_full_backref = 0;
7269                 ret = record_extent(trans, info, path, rec, back, allocated, flags);
7270                 allocated = 1;
7271
7272                 if (ret)
7273                         goto out;
7274         }
7275 out:
7276         if (trans) {
7277                 int err = btrfs_commit_transaction(trans, info->extent_root);
7278                 if (!ret)
7279                         ret = err;
7280         }
7281
7282         btrfs_free_path(path);
7283         return ret;
7284 }
7285
7286 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
7287                               struct extent_record *rec)
7288 {
7289         struct btrfs_trans_handle *trans;
7290         struct btrfs_root *root = fs_info->extent_root;
7291         struct btrfs_path *path;
7292         struct btrfs_extent_item *ei;
7293         struct btrfs_key key;
7294         u64 flags;
7295         int ret = 0;
7296
7297         key.objectid = rec->start;
7298         if (rec->metadata) {
7299                 key.type = BTRFS_METADATA_ITEM_KEY;
7300                 key.offset = rec->info_level;
7301         } else {
7302                 key.type = BTRFS_EXTENT_ITEM_KEY;
7303                 key.offset = rec->max_size;
7304         }
7305
7306         path = btrfs_alloc_path();
7307         if (!path)
7308                 return -ENOMEM;
7309
7310         trans = btrfs_start_transaction(root, 0);
7311         if (IS_ERR(trans)) {
7312                 btrfs_free_path(path);
7313                 return PTR_ERR(trans);
7314         }
7315
7316         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
7317         if (ret < 0) {
7318                 btrfs_free_path(path);
7319                 btrfs_commit_transaction(trans, root);
7320                 return ret;
7321         } else if (ret) {
7322                 fprintf(stderr, "Didn't find extent for %llu\n",
7323                         (unsigned long long)rec->start);
7324                 btrfs_free_path(path);
7325                 btrfs_commit_transaction(trans, root);
7326                 return -ENOENT;
7327         }
7328
7329         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
7330                             struct btrfs_extent_item);
7331         flags = btrfs_extent_flags(path->nodes[0], ei);
7332         if (rec->flag_block_full_backref) {
7333                 fprintf(stderr, "setting full backref on %llu\n",
7334                         (unsigned long long)key.objectid);
7335                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7336         } else {
7337                 fprintf(stderr, "clearing full backref on %llu\n",
7338                         (unsigned long long)key.objectid);
7339                 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7340         }
7341         btrfs_set_extent_flags(path->nodes[0], ei, flags);
7342         btrfs_mark_buffer_dirty(path->nodes[0]);
7343         btrfs_free_path(path);
7344         return btrfs_commit_transaction(trans, root);
7345 }
7346
7347 /* right now we only prune from the extent allocation tree */
7348 static int prune_one_block(struct btrfs_trans_handle *trans,
7349                            struct btrfs_fs_info *info,
7350                            struct btrfs_corrupt_block *corrupt)
7351 {
7352         int ret;
7353         struct btrfs_path path;
7354         struct extent_buffer *eb;
7355         u64 found;
7356         int slot;
7357         int nritems;
7358         int level = corrupt->level + 1;
7359
7360         btrfs_init_path(&path);
7361 again:
7362         /* we want to stop at the parent to our busted block */
7363         path.lowest_level = level;
7364
7365         ret = btrfs_search_slot(trans, info->extent_root,
7366                                 &corrupt->key, &path, -1, 1);
7367
7368         if (ret < 0)
7369                 goto out;
7370
7371         eb = path.nodes[level];
7372         if (!eb) {
7373                 ret = -ENOENT;
7374                 goto out;
7375         }
7376
7377         /*
7378          * hopefully the search gave us the block we want to prune,
7379          * lets try that first
7380          */
7381         slot = path.slots[level];
7382         found =  btrfs_node_blockptr(eb, slot);
7383         if (found == corrupt->cache.start)
7384                 goto del_ptr;
7385
7386         nritems = btrfs_header_nritems(eb);
7387
7388         /* the search failed, lets scan this node and hope we find it */
7389         for (slot = 0; slot < nritems; slot++) {
7390                 found =  btrfs_node_blockptr(eb, slot);
7391                 if (found == corrupt->cache.start)
7392                         goto del_ptr;
7393         }
7394         /*
7395          * we couldn't find the bad block.  TODO, search all the nodes for pointers
7396          * to this block
7397          */
7398         if (eb == info->extent_root->node) {
7399                 ret = -ENOENT;
7400                 goto out;
7401         } else {
7402                 level++;
7403                 btrfs_release_path(&path);
7404                 goto again;
7405         }
7406
7407 del_ptr:
7408         printk("deleting pointer to block %Lu\n", corrupt->cache.start);
7409         ret = btrfs_del_ptr(trans, info->extent_root, &path, level, slot);
7410
7411 out:
7412         btrfs_release_path(&path);
7413         return ret;
7414 }
7415
7416 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
7417 {
7418         struct btrfs_trans_handle *trans = NULL;
7419         struct cache_extent *cache;
7420         struct btrfs_corrupt_block *corrupt;
7421
7422         while (1) {
7423                 cache = search_cache_extent(info->corrupt_blocks, 0);
7424                 if (!cache)
7425                         break;
7426                 if (!trans) {
7427                         trans = btrfs_start_transaction(info->extent_root, 1);
7428                         if (IS_ERR(trans))
7429                                 return PTR_ERR(trans);
7430                 }
7431                 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
7432                 prune_one_block(trans, info, corrupt);
7433                 remove_cache_extent(info->corrupt_blocks, cache);
7434         }
7435         if (trans)
7436                 return btrfs_commit_transaction(trans, info->extent_root);
7437         return 0;
7438 }
7439
7440 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
7441 {
7442         struct btrfs_block_group_cache *cache;
7443         u64 start, end;
7444         int ret;
7445
7446         while (1) {
7447                 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
7448                                             &start, &end, EXTENT_DIRTY);
7449                 if (ret)
7450                         break;
7451                 clear_extent_dirty(&fs_info->free_space_cache, start, end,
7452                                    GFP_NOFS);
7453         }
7454
7455         start = 0;
7456         while (1) {
7457                 cache = btrfs_lookup_first_block_group(fs_info, start);
7458                 if (!cache)
7459                         break;
7460                 if (cache->cached)
7461                         cache->cached = 0;
7462                 start = cache->key.objectid + cache->key.offset;
7463         }
7464 }
7465
7466 static int check_extent_refs(struct btrfs_root *root,
7467                              struct cache_tree *extent_cache)
7468 {
7469         struct extent_record *rec;
7470         struct cache_extent *cache;
7471         int err = 0;
7472         int ret = 0;
7473         int fixed = 0;
7474         int had_dups = 0;
7475         int recorded = 0;
7476
7477         if (repair) {
7478                 /*
7479                  * if we're doing a repair, we have to make sure
7480                  * we don't allocate from the problem extents.
7481                  * In the worst case, this will be all the
7482                  * extents in the FS
7483                  */
7484                 cache = search_cache_extent(extent_cache, 0);
7485                 while(cache) {
7486                         rec = container_of(cache, struct extent_record, cache);
7487                         set_extent_dirty(root->fs_info->excluded_extents,
7488                                          rec->start,
7489                                          rec->start + rec->max_size - 1,
7490                                          GFP_NOFS);
7491                         cache = next_cache_extent(cache);
7492                 }
7493
7494                 /* pin down all the corrupted blocks too */
7495                 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
7496                 while(cache) {
7497                         set_extent_dirty(root->fs_info->excluded_extents,
7498                                          cache->start,
7499                                          cache->start + cache->size - 1,
7500                                          GFP_NOFS);
7501                         cache = next_cache_extent(cache);
7502                 }
7503                 prune_corrupt_blocks(root->fs_info);
7504                 reset_cached_block_groups(root->fs_info);
7505         }
7506
7507         reset_cached_block_groups(root->fs_info);
7508
7509         /*
7510          * We need to delete any duplicate entries we find first otherwise we
7511          * could mess up the extent tree when we have backrefs that actually
7512          * belong to a different extent item and not the weird duplicate one.
7513          */
7514         while (repair && !list_empty(&duplicate_extents)) {
7515                 rec = list_entry(duplicate_extents.next, struct extent_record,
7516                                  list);
7517                 list_del_init(&rec->list);
7518
7519                 /* Sometimes we can find a backref before we find an actual
7520                  * extent, so we need to process it a little bit to see if there
7521                  * truly are multiple EXTENT_ITEM_KEY's for the same range, or
7522                  * if this is a backref screwup.  If we need to delete stuff
7523                  * process_duplicates() will return 0, otherwise it will return
7524                  * 1 and we
7525                  */
7526                 if (process_duplicates(root, extent_cache, rec))
7527                         continue;
7528                 ret = delete_duplicate_records(root, rec);
7529                 if (ret < 0)
7530                         return ret;
7531                 /*
7532                  * delete_duplicate_records will return the number of entries
7533                  * deleted, so if it's greater than 0 then we know we actually
7534                  * did something and we need to remove.
7535                  */
7536                 if (ret)
7537                         had_dups = 1;
7538         }
7539
7540         if (had_dups)
7541                 return -EAGAIN;
7542
7543         while(1) {
7544                 int cur_err = 0;
7545
7546                 fixed = 0;
7547                 recorded = 0;
7548                 cache = search_cache_extent(extent_cache, 0);
7549                 if (!cache)
7550                         break;
7551                 rec = container_of(cache, struct extent_record, cache);
7552                 if (rec->num_duplicates) {
7553                         fprintf(stderr, "extent item %llu has multiple extent "
7554                                 "items\n", (unsigned long long)rec->start);
7555                         err = 1;
7556                         cur_err = 1;
7557                 }
7558
7559                 if (rec->refs != rec->extent_item_refs) {
7560                         fprintf(stderr, "ref mismatch on [%llu %llu] ",
7561                                 (unsigned long long)rec->start,
7562                                 (unsigned long long)rec->nr);
7563                         fprintf(stderr, "extent item %llu, found %llu\n",
7564                                 (unsigned long long)rec->extent_item_refs,
7565                                 (unsigned long long)rec->refs);
7566                         ret = record_orphan_data_extents(root->fs_info, rec);
7567                         if (ret < 0)
7568                                 goto repair_abort;
7569                         if (ret == 0) {
7570                                 recorded = 1;
7571                         } else {
7572                                 /*
7573                                  * we can't use the extent to repair file
7574                                  * extent, let the fallback method handle it.
7575                                  */
7576                                 if (!fixed && repair) {
7577                                         ret = fixup_extent_refs(
7578                                                         root->fs_info,
7579                                                         extent_cache, rec);
7580                                         if (ret)
7581                                                 goto repair_abort;
7582                                         fixed = 1;
7583                                 }
7584                         }
7585                         err = 1;
7586                         cur_err = 1;
7587                 }
7588                 if (all_backpointers_checked(rec, 1)) {
7589                         fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
7590                                 (unsigned long long)rec->start,
7591                                 (unsigned long long)rec->nr);
7592
7593                         if (!fixed && !recorded && repair) {
7594                                 ret = fixup_extent_refs(root->fs_info,
7595                                                         extent_cache, rec);
7596                                 if (ret)
7597                                         goto repair_abort;
7598                                 fixed = 1;
7599                         }
7600                         cur_err = 1;
7601                         err = 1;
7602                 }
7603                 if (!rec->owner_ref_checked) {
7604                         fprintf(stderr, "owner ref check failed [%llu %llu]\n",
7605                                 (unsigned long long)rec->start,
7606                                 (unsigned long long)rec->nr);
7607                         if (!fixed && !recorded && repair) {
7608                                 ret = fixup_extent_refs(root->fs_info,
7609                                                         extent_cache, rec);
7610                                 if (ret)
7611                                         goto repair_abort;
7612                                 fixed = 1;
7613                         }
7614                         err = 1;
7615                         cur_err = 1;
7616                 }
7617                 if (rec->bad_full_backref) {
7618                         fprintf(stderr, "bad full backref, on [%llu]\n",
7619                                 (unsigned long long)rec->start);
7620                         if (repair) {
7621                                 ret = fixup_extent_flags(root->fs_info, rec);
7622                                 if (ret)
7623                                         goto repair_abort;
7624                                 fixed = 1;
7625                         }
7626                         err = 1;
7627                         cur_err = 1;
7628                 }
7629                 /*
7630                  * Although it's not a extent ref's problem, we reuse this
7631                  * routine for error reporting.
7632                  * No repair function yet.
7633                  */
7634                 if (rec->crossing_stripes) {
7635                         fprintf(stderr,
7636                                 "bad metadata [%llu, %llu) crossing stripe boundary\n",
7637                                 rec->start, rec->start + rec->max_size);
7638                         err = 1;
7639                         cur_err = 1;
7640                 }
7641
7642                 if (rec->wrong_chunk_type) {
7643                         fprintf(stderr,
7644                                 "bad extent [%llu, %llu), type mismatch with chunk\n",
7645                                 rec->start, rec->start + rec->max_size);
7646                         err = 1;
7647                         cur_err = 1;
7648                 }
7649
7650                 remove_cache_extent(extent_cache, cache);
7651                 free_all_extent_backrefs(rec);
7652                 if (!init_extent_tree && repair && (!cur_err || fixed))
7653                         clear_extent_dirty(root->fs_info->excluded_extents,
7654                                            rec->start,
7655                                            rec->start + rec->max_size - 1,
7656                                            GFP_NOFS);
7657                 free(rec);
7658         }
7659 repair_abort:
7660         if (repair) {
7661                 if (ret && ret != -EAGAIN) {
7662                         fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
7663                         exit(1);
7664                 } else if (!ret) {
7665                         struct btrfs_trans_handle *trans;
7666
7667                         root = root->fs_info->extent_root;
7668                         trans = btrfs_start_transaction(root, 1);
7669                         if (IS_ERR(trans)) {
7670                                 ret = PTR_ERR(trans);
7671                                 goto repair_abort;
7672                         }
7673
7674                         btrfs_fix_block_accounting(trans, root);
7675                         ret = btrfs_commit_transaction(trans, root);
7676                         if (ret)
7677                                 goto repair_abort;
7678                 }
7679                 if (err)
7680                         fprintf(stderr, "repaired damaged extent references\n");
7681                 return ret;
7682         }
7683         return err;
7684 }
7685
7686 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
7687 {
7688         u64 stripe_size;
7689
7690         if (type & BTRFS_BLOCK_GROUP_RAID0) {
7691                 stripe_size = length;
7692                 stripe_size /= num_stripes;
7693         } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
7694                 stripe_size = length * 2;
7695                 stripe_size /= num_stripes;
7696         } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
7697                 stripe_size = length;
7698                 stripe_size /= (num_stripes - 1);
7699         } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
7700                 stripe_size = length;
7701                 stripe_size /= (num_stripes - 2);
7702         } else {
7703                 stripe_size = length;
7704         }
7705         return stripe_size;
7706 }
7707
7708 /*
7709  * Check the chunk with its block group/dev list ref:
7710  * Return 0 if all refs seems valid.
7711  * Return 1 if part of refs seems valid, need later check for rebuild ref
7712  * like missing block group and needs to search extent tree to rebuild them.
7713  * Return -1 if essential refs are missing and unable to rebuild.
7714  */
7715 static int check_chunk_refs(struct chunk_record *chunk_rec,
7716                             struct block_group_tree *block_group_cache,
7717                             struct device_extent_tree *dev_extent_cache,
7718                             int silent)
7719 {
7720         struct cache_extent *block_group_item;
7721         struct block_group_record *block_group_rec;
7722         struct cache_extent *dev_extent_item;
7723         struct device_extent_record *dev_extent_rec;
7724         u64 devid;
7725         u64 offset;
7726         u64 length;
7727         int metadump_v2 = 0;
7728         int i;
7729         int ret = 0;
7730
7731         block_group_item = lookup_cache_extent(&block_group_cache->tree,
7732                                                chunk_rec->offset,
7733                                                chunk_rec->length);
7734         if (block_group_item) {
7735                 block_group_rec = container_of(block_group_item,
7736                                                struct block_group_record,
7737                                                cache);
7738                 if (chunk_rec->length != block_group_rec->offset ||
7739                     chunk_rec->offset != block_group_rec->objectid ||
7740                     (!metadump_v2 &&
7741                      chunk_rec->type_flags != block_group_rec->flags)) {
7742                         if (!silent)
7743                                 fprintf(stderr,
7744                                         "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
7745                                         chunk_rec->objectid,
7746                                         chunk_rec->type,
7747                                         chunk_rec->offset,
7748                                         chunk_rec->length,
7749                                         chunk_rec->offset,
7750                                         chunk_rec->type_flags,
7751                                         block_group_rec->objectid,
7752                                         block_group_rec->type,
7753                                         block_group_rec->offset,
7754                                         block_group_rec->offset,
7755                                         block_group_rec->objectid,
7756                                         block_group_rec->flags);
7757                         ret = -1;
7758                 } else {
7759                         list_del_init(&block_group_rec->list);
7760                         chunk_rec->bg_rec = block_group_rec;
7761                 }
7762         } else {
7763                 if (!silent)
7764                         fprintf(stderr,
7765                                 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
7766                                 chunk_rec->objectid,
7767                                 chunk_rec->type,
7768                                 chunk_rec->offset,
7769                                 chunk_rec->length,
7770                                 chunk_rec->offset,
7771                                 chunk_rec->type_flags);
7772                 ret = 1;
7773         }
7774
7775         if (metadump_v2)
7776                 return ret;
7777
7778         length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
7779                                     chunk_rec->num_stripes);
7780         for (i = 0; i < chunk_rec->num_stripes; ++i) {
7781                 devid = chunk_rec->stripes[i].devid;
7782                 offset = chunk_rec->stripes[i].offset;
7783                 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
7784                                                        devid, offset, length);
7785                 if (dev_extent_item) {
7786                         dev_extent_rec = container_of(dev_extent_item,
7787                                                 struct device_extent_record,
7788                                                 cache);
7789                         if (dev_extent_rec->objectid != devid ||
7790                             dev_extent_rec->offset != offset ||
7791                             dev_extent_rec->chunk_offset != chunk_rec->offset ||
7792                             dev_extent_rec->length != length) {
7793                                 if (!silent)
7794                                         fprintf(stderr,
7795                                                 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
7796                                                 chunk_rec->objectid,
7797                                                 chunk_rec->type,
7798                                                 chunk_rec->offset,
7799                                                 chunk_rec->stripes[i].devid,
7800                                                 chunk_rec->stripes[i].offset,
7801                                                 dev_extent_rec->objectid,
7802                                                 dev_extent_rec->offset,
7803                                                 dev_extent_rec->length);
7804                                 ret = -1;
7805                         } else {
7806                                 list_move(&dev_extent_rec->chunk_list,
7807                                           &chunk_rec->dextents);
7808                         }
7809                 } else {
7810                         if (!silent)
7811                                 fprintf(stderr,
7812                                         "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
7813                                         chunk_rec->objectid,
7814                                         chunk_rec->type,
7815                                         chunk_rec->offset,
7816                                         chunk_rec->stripes[i].devid,
7817                                         chunk_rec->stripes[i].offset);
7818                         ret = -1;
7819                 }
7820         }
7821         return ret;
7822 }
7823
7824 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
7825 int check_chunks(struct cache_tree *chunk_cache,
7826                  struct block_group_tree *block_group_cache,
7827                  struct device_extent_tree *dev_extent_cache,
7828                  struct list_head *good, struct list_head *bad,
7829                  struct list_head *rebuild, int silent)
7830 {
7831         struct cache_extent *chunk_item;
7832         struct chunk_record *chunk_rec;
7833         struct block_group_record *bg_rec;
7834         struct device_extent_record *dext_rec;
7835         int err;
7836         int ret = 0;
7837
7838         chunk_item = first_cache_extent(chunk_cache);
7839         while (chunk_item) {
7840                 chunk_rec = container_of(chunk_item, struct chunk_record,
7841                                          cache);
7842                 err = check_chunk_refs(chunk_rec, block_group_cache,
7843                                        dev_extent_cache, silent);
7844                 if (err < 0)
7845                         ret = err;
7846                 if (err == 0 && good)
7847                         list_add_tail(&chunk_rec->list, good);
7848                 if (err > 0 && rebuild)
7849                         list_add_tail(&chunk_rec->list, rebuild);
7850                 if (err < 0 && bad)
7851                         list_add_tail(&chunk_rec->list, bad);
7852                 chunk_item = next_cache_extent(chunk_item);
7853         }
7854
7855         list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
7856                 if (!silent)
7857                         fprintf(stderr,
7858                                 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
7859                                 bg_rec->objectid,
7860                                 bg_rec->offset,
7861                                 bg_rec->flags);
7862                 if (!ret)
7863                         ret = 1;
7864         }
7865
7866         list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
7867                             chunk_list) {
7868                 if (!silent)
7869                         fprintf(stderr,
7870                                 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
7871                                 dext_rec->objectid,
7872                                 dext_rec->offset,
7873                                 dext_rec->length);
7874                 if (!ret)
7875                         ret = 1;
7876         }
7877         return ret;
7878 }
7879
7880
7881 static int check_device_used(struct device_record *dev_rec,
7882                              struct device_extent_tree *dext_cache)
7883 {
7884         struct cache_extent *cache;
7885         struct device_extent_record *dev_extent_rec;
7886         u64 total_byte = 0;
7887
7888         cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
7889         while (cache) {
7890                 dev_extent_rec = container_of(cache,
7891                                               struct device_extent_record,
7892                                               cache);
7893                 if (dev_extent_rec->objectid != dev_rec->devid)
7894                         break;
7895
7896                 list_del_init(&dev_extent_rec->device_list);
7897                 total_byte += dev_extent_rec->length;
7898                 cache = next_cache_extent(cache);
7899         }
7900
7901         if (total_byte != dev_rec->byte_used) {
7902                 fprintf(stderr,
7903                         "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
7904                         total_byte, dev_rec->byte_used, dev_rec->objectid,
7905                         dev_rec->type, dev_rec->offset);
7906                 return -1;
7907         } else {
7908                 return 0;
7909         }
7910 }
7911
7912 /* check btrfs_dev_item -> btrfs_dev_extent */
7913 static int check_devices(struct rb_root *dev_cache,
7914                          struct device_extent_tree *dev_extent_cache)
7915 {
7916         struct rb_node *dev_node;
7917         struct device_record *dev_rec;
7918         struct device_extent_record *dext_rec;
7919         int err;
7920         int ret = 0;
7921
7922         dev_node = rb_first(dev_cache);
7923         while (dev_node) {
7924                 dev_rec = container_of(dev_node, struct device_record, node);
7925                 err = check_device_used(dev_rec, dev_extent_cache);
7926                 if (err)
7927                         ret = err;
7928
7929                 dev_node = rb_next(dev_node);
7930         }
7931         list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
7932                             device_list) {
7933                 fprintf(stderr,
7934                         "Device extent[%llu, %llu, %llu] didn't find its device.\n",
7935                         dext_rec->objectid, dext_rec->offset, dext_rec->length);
7936                 if (!ret)
7937                         ret = 1;
7938         }
7939         return ret;
7940 }
7941
7942 static int add_root_item_to_list(struct list_head *head,
7943                                   u64 objectid, u64 bytenr, u64 last_snapshot,
7944                                   u8 level, u8 drop_level,
7945                                   int level_size, struct btrfs_key *drop_key)
7946 {
7947
7948         struct root_item_record *ri_rec;
7949         ri_rec = malloc(sizeof(*ri_rec));
7950         if (!ri_rec)
7951                 return -ENOMEM;
7952         ri_rec->bytenr = bytenr;
7953         ri_rec->objectid = objectid;
7954         ri_rec->level = level;
7955         ri_rec->level_size = level_size;
7956         ri_rec->drop_level = drop_level;
7957         ri_rec->last_snapshot = last_snapshot;
7958         if (drop_key)
7959                 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
7960         list_add_tail(&ri_rec->list, head);
7961
7962         return 0;
7963 }
7964
7965 static void free_root_item_list(struct list_head *list)
7966 {
7967         struct root_item_record *ri_rec;
7968
7969         while (!list_empty(list)) {
7970                 ri_rec = list_first_entry(list, struct root_item_record,
7971                                           list);
7972                 list_del_init(&ri_rec->list);
7973                 free(ri_rec);
7974         }
7975 }
7976
7977 static int deal_root_from_list(struct list_head *list,
7978                                struct btrfs_root *root,
7979                                struct block_info *bits,
7980                                int bits_nr,
7981                                struct cache_tree *pending,
7982                                struct cache_tree *seen,
7983                                struct cache_tree *reada,
7984                                struct cache_tree *nodes,
7985                                struct cache_tree *extent_cache,
7986                                struct cache_tree *chunk_cache,
7987                                struct rb_root *dev_cache,
7988                                struct block_group_tree *block_group_cache,
7989                                struct device_extent_tree *dev_extent_cache)
7990 {
7991         int ret = 0;
7992         u64 last;
7993
7994         while (!list_empty(list)) {
7995                 struct root_item_record *rec;
7996                 struct extent_buffer *buf;
7997                 rec = list_entry(list->next,
7998                                  struct root_item_record, list);
7999                 last = 0;
8000                 buf = read_tree_block(root->fs_info->tree_root,
8001                                       rec->bytenr, rec->level_size, 0);
8002                 if (!extent_buffer_uptodate(buf)) {
8003                         free_extent_buffer(buf);
8004                         ret = -EIO;
8005                         break;
8006                 }
8007                 add_root_to_pending(buf, extent_cache, pending,
8008                                     seen, nodes, rec->objectid);
8009                 /*
8010                  * To rebuild extent tree, we need deal with snapshot
8011                  * one by one, otherwise we deal with node firstly which
8012                  * can maximize readahead.
8013                  */
8014                 while (1) {
8015                         ret = run_next_block(root, bits, bits_nr, &last,
8016                                              pending, seen, reada, nodes,
8017                                              extent_cache, chunk_cache,
8018                                              dev_cache, block_group_cache,
8019                                              dev_extent_cache, rec);
8020                         if (ret != 0)
8021                                 break;
8022                 }
8023                 free_extent_buffer(buf);
8024                 list_del(&rec->list);
8025                 free(rec);
8026                 if (ret < 0)
8027                         break;
8028         }
8029         while (ret >= 0) {
8030                 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
8031                                      reada, nodes, extent_cache, chunk_cache,
8032                                      dev_cache, block_group_cache,
8033                                      dev_extent_cache, NULL);
8034                 if (ret != 0) {
8035                         if (ret > 0)
8036                                 ret = 0;
8037                         break;
8038                 }
8039         }
8040         return ret;
8041 }
8042
8043 static int check_chunks_and_extents(struct btrfs_root *root)
8044 {
8045         struct rb_root dev_cache;
8046         struct cache_tree chunk_cache;
8047         struct block_group_tree block_group_cache;
8048         struct device_extent_tree dev_extent_cache;
8049         struct cache_tree extent_cache;
8050         struct cache_tree seen;
8051         struct cache_tree pending;
8052         struct cache_tree reada;
8053         struct cache_tree nodes;
8054         struct extent_io_tree excluded_extents;
8055         struct cache_tree corrupt_blocks;
8056         struct btrfs_path path;
8057         struct btrfs_key key;
8058         struct btrfs_key found_key;
8059         int ret, err = 0;
8060         struct block_info *bits;
8061         int bits_nr;
8062         struct extent_buffer *leaf;
8063         int slot;
8064         struct btrfs_root_item ri;
8065         struct list_head dropping_trees;
8066         struct list_head normal_trees;
8067         struct btrfs_root *root1;
8068         u64 objectid;
8069         u32 level_size;
8070         u8 level;
8071
8072         dev_cache = RB_ROOT;
8073         cache_tree_init(&chunk_cache);
8074         block_group_tree_init(&block_group_cache);
8075         device_extent_tree_init(&dev_extent_cache);
8076
8077         cache_tree_init(&extent_cache);
8078         cache_tree_init(&seen);
8079         cache_tree_init(&pending);
8080         cache_tree_init(&nodes);
8081         cache_tree_init(&reada);
8082         cache_tree_init(&corrupt_blocks);
8083         extent_io_tree_init(&excluded_extents);
8084         INIT_LIST_HEAD(&dropping_trees);
8085         INIT_LIST_HEAD(&normal_trees);
8086
8087         if (repair) {
8088                 root->fs_info->excluded_extents = &excluded_extents;
8089                 root->fs_info->fsck_extent_cache = &extent_cache;
8090                 root->fs_info->free_extent_hook = free_extent_hook;
8091                 root->fs_info->corrupt_blocks = &corrupt_blocks;
8092         }
8093
8094         bits_nr = 1024;
8095         bits = malloc(bits_nr * sizeof(struct block_info));
8096         if (!bits) {
8097                 perror("malloc");
8098                 exit(1);
8099         }
8100
8101         if (ctx.progress_enabled) {
8102                 ctx.tp = TASK_EXTENTS;
8103                 task_start(ctx.info);
8104         }
8105
8106 again:
8107         root1 = root->fs_info->tree_root;
8108         level = btrfs_header_level(root1->node);
8109         ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
8110                                     root1->node->start, 0, level, 0,
8111                                     btrfs_level_size(root1, level), NULL);
8112         if (ret < 0)
8113                 goto out;
8114         root1 = root->fs_info->chunk_root;
8115         level = btrfs_header_level(root1->node);
8116         ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
8117                                     root1->node->start, 0, level, 0,
8118                                     btrfs_level_size(root1, level), NULL);
8119         if (ret < 0)
8120                 goto out;
8121         btrfs_init_path(&path);
8122         key.offset = 0;
8123         key.objectid = 0;
8124         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
8125         ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
8126                                         &key, &path, 0, 0);
8127         if (ret < 0)
8128                 goto out;
8129         while(1) {
8130                 leaf = path.nodes[0];
8131                 slot = path.slots[0];
8132                 if (slot >= btrfs_header_nritems(path.nodes[0])) {
8133                         ret = btrfs_next_leaf(root, &path);
8134                         if (ret != 0)
8135                                 break;
8136                         leaf = path.nodes[0];
8137                         slot = path.slots[0];
8138                 }
8139                 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
8140                 if (btrfs_key_type(&found_key) == BTRFS_ROOT_ITEM_KEY) {
8141                         unsigned long offset;
8142                         u64 last_snapshot;
8143
8144                         offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
8145                         read_extent_buffer(leaf, &ri, offset, sizeof(ri));
8146                         last_snapshot = btrfs_root_last_snapshot(&ri);
8147                         if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
8148                                 level = btrfs_root_level(&ri);
8149                                 level_size = btrfs_level_size(root, level);
8150                                 ret = add_root_item_to_list(&normal_trees,
8151                                                 found_key.objectid,
8152                                                 btrfs_root_bytenr(&ri),
8153                                                 last_snapshot, level,
8154                                                 0, level_size, NULL);
8155                                 if (ret < 0)
8156                                         goto out;
8157                         } else {
8158                                 level = btrfs_root_level(&ri);
8159                                 level_size = btrfs_level_size(root, level);
8160                                 objectid = found_key.objectid;
8161                                 btrfs_disk_key_to_cpu(&found_key,
8162                                                       &ri.drop_progress);
8163                                 ret = add_root_item_to_list(&dropping_trees,
8164                                                 objectid,
8165                                                 btrfs_root_bytenr(&ri),
8166                                                 last_snapshot, level,
8167                                                 ri.drop_level,
8168                                                 level_size, &found_key);
8169                                 if (ret < 0)
8170                                         goto out;
8171                         }
8172                 }
8173                 path.slots[0]++;
8174         }
8175         btrfs_release_path(&path);
8176
8177         /*
8178          * check_block can return -EAGAIN if it fixes something, please keep
8179          * this in mind when dealing with return values from these functions, if
8180          * we get -EAGAIN we want to fall through and restart the loop.
8181          */
8182         ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
8183                                   &seen, &reada, &nodes, &extent_cache,
8184                                   &chunk_cache, &dev_cache, &block_group_cache,
8185                                   &dev_extent_cache);
8186         if (ret < 0) {
8187                 if (ret == -EAGAIN)
8188                         goto loop;
8189                 goto out;
8190         }
8191         ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
8192                                   &pending, &seen, &reada, &nodes,
8193                                   &extent_cache, &chunk_cache, &dev_cache,
8194                                   &block_group_cache, &dev_extent_cache);
8195         if (ret < 0) {
8196                 if (ret == -EAGAIN)
8197                         goto loop;
8198                 goto out;
8199         }
8200
8201         ret = check_chunks(&chunk_cache, &block_group_cache,
8202                            &dev_extent_cache, NULL, NULL, NULL, 0);
8203         if (ret) {
8204                 if (ret == -EAGAIN)
8205                         goto loop;
8206                 err = ret;
8207         }
8208
8209         ret = check_extent_refs(root, &extent_cache);
8210         if (ret < 0) {
8211                 if (ret == -EAGAIN)
8212                         goto loop;
8213                 goto out;
8214         }
8215
8216         ret = check_devices(&dev_cache, &dev_extent_cache);
8217         if (ret && err)
8218                 ret = err;
8219
8220 out:
8221         task_stop(ctx.info);
8222         if (repair) {
8223                 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
8224                 extent_io_tree_cleanup(&excluded_extents);
8225                 root->fs_info->fsck_extent_cache = NULL;
8226                 root->fs_info->free_extent_hook = NULL;
8227                 root->fs_info->corrupt_blocks = NULL;
8228                 root->fs_info->excluded_extents = NULL;
8229         }
8230         free(bits);
8231         free_chunk_cache_tree(&chunk_cache);
8232         free_device_cache_tree(&dev_cache);
8233         free_block_group_tree(&block_group_cache);
8234         free_device_extent_tree(&dev_extent_cache);
8235         free_extent_cache_tree(&seen);
8236         free_extent_cache_tree(&pending);
8237         free_extent_cache_tree(&reada);
8238         free_extent_cache_tree(&nodes);
8239         return ret;
8240 loop:
8241         free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
8242         free_extent_cache_tree(&seen);
8243         free_extent_cache_tree(&pending);
8244         free_extent_cache_tree(&reada);
8245         free_extent_cache_tree(&nodes);
8246         free_chunk_cache_tree(&chunk_cache);
8247         free_block_group_tree(&block_group_cache);
8248         free_device_cache_tree(&dev_cache);
8249         free_device_extent_tree(&dev_extent_cache);
8250         free_extent_record_cache(root->fs_info, &extent_cache);
8251         free_root_item_list(&normal_trees);
8252         free_root_item_list(&dropping_trees);
8253         extent_io_tree_cleanup(&excluded_extents);
8254         goto again;
8255 }
8256
8257 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
8258                            struct btrfs_root *root, int overwrite)
8259 {
8260         struct extent_buffer *c;
8261         struct extent_buffer *old = root->node;
8262         int level;
8263         int ret;
8264         struct btrfs_disk_key disk_key = {0,0,0};
8265
8266         level = 0;
8267
8268         if (overwrite) {
8269                 c = old;
8270                 extent_buffer_get(c);
8271                 goto init;
8272         }
8273         c = btrfs_alloc_free_block(trans, root,
8274                                    btrfs_level_size(root, 0),
8275                                    root->root_key.objectid,
8276                                    &disk_key, level, 0, 0);
8277         if (IS_ERR(c)) {
8278                 c = old;
8279                 extent_buffer_get(c);
8280                 overwrite = 1;
8281         }
8282 init:
8283         memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
8284         btrfs_set_header_level(c, level);
8285         btrfs_set_header_bytenr(c, c->start);
8286         btrfs_set_header_generation(c, trans->transid);
8287         btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
8288         btrfs_set_header_owner(c, root->root_key.objectid);
8289
8290         write_extent_buffer(c, root->fs_info->fsid,
8291                             btrfs_header_fsid(), BTRFS_FSID_SIZE);
8292
8293         write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
8294                             btrfs_header_chunk_tree_uuid(c),
8295                             BTRFS_UUID_SIZE);
8296
8297         btrfs_mark_buffer_dirty(c);
8298         /*
8299          * this case can happen in the following case:
8300          *
8301          * 1.overwrite previous root.
8302          *
8303          * 2.reinit reloc data root, this is because we skip pin
8304          * down reloc data tree before which means we can allocate
8305          * same block bytenr here.
8306          */
8307         if (old->start == c->start) {
8308                 btrfs_set_root_generation(&root->root_item,
8309                                           trans->transid);
8310                 root->root_item.level = btrfs_header_level(root->node);
8311                 ret = btrfs_update_root(trans, root->fs_info->tree_root,
8312                                         &root->root_key, &root->root_item);
8313                 if (ret) {
8314                         free_extent_buffer(c);
8315                         return ret;
8316                 }
8317         }
8318         free_extent_buffer(old);
8319         root->node = c;
8320         add_root_to_dirty_list(root);
8321         return 0;
8322 }
8323
8324 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
8325                                 struct extent_buffer *eb, int tree_root)
8326 {
8327         struct extent_buffer *tmp;
8328         struct btrfs_root_item *ri;
8329         struct btrfs_key key;
8330         u64 bytenr;
8331         u32 leafsize;
8332         int level = btrfs_header_level(eb);
8333         int nritems;
8334         int ret;
8335         int i;
8336
8337         /*
8338          * If we have pinned this block before, don't pin it again.
8339          * This can not only avoid forever loop with broken filesystem
8340          * but also give us some speedups.
8341          */
8342         if (test_range_bit(&fs_info->pinned_extents, eb->start,
8343                            eb->start + eb->len - 1, EXTENT_DIRTY, 0))
8344                 return 0;
8345
8346         btrfs_pin_extent(fs_info, eb->start, eb->len);
8347
8348         leafsize = btrfs_super_leafsize(fs_info->super_copy);
8349         nritems = btrfs_header_nritems(eb);
8350         for (i = 0; i < nritems; i++) {
8351                 if (level == 0) {
8352                         btrfs_item_key_to_cpu(eb, &key, i);
8353                         if (key.type != BTRFS_ROOT_ITEM_KEY)
8354                                 continue;
8355                         /* Skip the extent root and reloc roots */
8356                         if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
8357                             key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
8358                             key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
8359                                 continue;
8360                         ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
8361                         bytenr = btrfs_disk_root_bytenr(eb, ri);
8362
8363                         /*
8364                          * If at any point we start needing the real root we
8365                          * will have to build a stump root for the root we are
8366                          * in, but for now this doesn't actually use the root so
8367                          * just pass in extent_root.
8368                          */
8369                         tmp = read_tree_block(fs_info->extent_root, bytenr,
8370                                               leafsize, 0);
8371                         if (!extent_buffer_uptodate(tmp)) {
8372                                 fprintf(stderr, "Error reading root block\n");
8373                                 return -EIO;
8374                         }
8375                         ret = pin_down_tree_blocks(fs_info, tmp, 0);
8376                         free_extent_buffer(tmp);
8377                         if (ret)
8378                                 return ret;
8379                 } else {
8380                         bytenr = btrfs_node_blockptr(eb, i);
8381
8382                         /* If we aren't the tree root don't read the block */
8383                         if (level == 1 && !tree_root) {
8384                                 btrfs_pin_extent(fs_info, bytenr, leafsize);
8385                                 continue;
8386                         }
8387
8388                         tmp = read_tree_block(fs_info->extent_root, bytenr,
8389                                               leafsize, 0);
8390                         if (!extent_buffer_uptodate(tmp)) {
8391                                 fprintf(stderr, "Error reading tree block\n");
8392                                 return -EIO;
8393                         }
8394                         ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
8395                         free_extent_buffer(tmp);
8396                         if (ret)
8397                                 return ret;
8398                 }
8399         }
8400
8401         return 0;
8402 }
8403
8404 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
8405 {
8406         int ret;
8407
8408         ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
8409         if (ret)
8410                 return ret;
8411
8412         return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
8413 }
8414
8415 static int reset_block_groups(struct btrfs_fs_info *fs_info)
8416 {
8417         struct btrfs_block_group_cache *cache;
8418         struct btrfs_path *path;
8419         struct extent_buffer *leaf;
8420         struct btrfs_chunk *chunk;
8421         struct btrfs_key key;
8422         int ret;
8423         u64 start;
8424
8425         path = btrfs_alloc_path();
8426         if (!path)
8427                 return -ENOMEM;
8428
8429         key.objectid = 0;
8430         key.type = BTRFS_CHUNK_ITEM_KEY;
8431         key.offset = 0;
8432
8433         ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, path, 0, 0);
8434         if (ret < 0) {
8435                 btrfs_free_path(path);
8436                 return ret;
8437         }
8438
8439         /*
8440          * We do this in case the block groups were screwed up and had alloc
8441          * bits that aren't actually set on the chunks.  This happens with
8442          * restored images every time and could happen in real life I guess.
8443          */
8444         fs_info->avail_data_alloc_bits = 0;
8445         fs_info->avail_metadata_alloc_bits = 0;
8446         fs_info->avail_system_alloc_bits = 0;
8447
8448         /* First we need to create the in-memory block groups */
8449         while (1) {
8450                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8451                         ret = btrfs_next_leaf(fs_info->chunk_root, path);
8452                         if (ret < 0) {
8453                                 btrfs_free_path(path);
8454                                 return ret;
8455                         }
8456                         if (ret) {
8457                                 ret = 0;
8458                                 break;
8459                         }
8460                 }
8461                 leaf = path->nodes[0];
8462                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8463                 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
8464                         path->slots[0]++;
8465                         continue;
8466                 }
8467
8468                 chunk = btrfs_item_ptr(leaf, path->slots[0],
8469                                        struct btrfs_chunk);
8470                 btrfs_add_block_group(fs_info, 0,
8471                                       btrfs_chunk_type(leaf, chunk),
8472                                       key.objectid, key.offset,
8473                                       btrfs_chunk_length(leaf, chunk));
8474                 set_extent_dirty(&fs_info->free_space_cache, key.offset,
8475                                  key.offset + btrfs_chunk_length(leaf, chunk),
8476                                  GFP_NOFS);
8477                 path->slots[0]++;
8478         }
8479         start = 0;
8480         while (1) {
8481                 cache = btrfs_lookup_first_block_group(fs_info, start);
8482                 if (!cache)
8483                         break;
8484                 cache->cached = 1;
8485                 start = cache->key.objectid + cache->key.offset;
8486         }
8487
8488         btrfs_free_path(path);
8489         return 0;
8490 }
8491
8492 static int reset_balance(struct btrfs_trans_handle *trans,
8493                          struct btrfs_fs_info *fs_info)
8494 {
8495         struct btrfs_root *root = fs_info->tree_root;
8496         struct btrfs_path *path;
8497         struct extent_buffer *leaf;
8498         struct btrfs_key key;
8499         int del_slot, del_nr = 0;
8500         int ret;
8501         int found = 0;
8502
8503         path = btrfs_alloc_path();
8504         if (!path)
8505                 return -ENOMEM;
8506
8507         key.objectid = BTRFS_BALANCE_OBJECTID;
8508         key.type = BTRFS_BALANCE_ITEM_KEY;
8509         key.offset = 0;
8510
8511         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8512         if (ret) {
8513                 if (ret > 0)
8514                         ret = 0;
8515                 if (!ret)
8516                         goto reinit_data_reloc;
8517                 else
8518                         goto out;
8519         }
8520
8521         ret = btrfs_del_item(trans, root, path);
8522         if (ret)
8523                 goto out;
8524         btrfs_release_path(path);
8525
8526         key.objectid = BTRFS_TREE_RELOC_OBJECTID;
8527         key.type = BTRFS_ROOT_ITEM_KEY;
8528         key.offset = 0;
8529
8530         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8531         if (ret < 0)
8532                 goto out;
8533         while (1) {
8534                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8535                         if (!found)
8536                                 break;
8537
8538                         if (del_nr) {
8539                                 ret = btrfs_del_items(trans, root, path,
8540                                                       del_slot, del_nr);
8541                                 del_nr = 0;
8542                                 if (ret)
8543                                         goto out;
8544                         }
8545                         key.offset++;
8546                         btrfs_release_path(path);
8547
8548                         found = 0;
8549                         ret = btrfs_search_slot(trans, root, &key, path,
8550                                                 -1, 1);
8551                         if (ret < 0)
8552                                 goto out;
8553                         continue;
8554                 }
8555                 found = 1;
8556                 leaf = path->nodes[0];
8557                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8558                 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
8559                         break;
8560                 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
8561                         path->slots[0]++;
8562                         continue;
8563                 }
8564                 if (!del_nr) {
8565                         del_slot = path->slots[0];
8566                         del_nr = 1;
8567                 } else {
8568                         del_nr++;
8569                 }
8570                 path->slots[0]++;
8571         }
8572
8573         if (del_nr) {
8574                 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
8575                 if (ret)
8576                         goto out;
8577         }
8578         btrfs_release_path(path);
8579
8580 reinit_data_reloc:
8581         key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
8582         key.type = BTRFS_ROOT_ITEM_KEY;
8583         key.offset = (u64)-1;
8584         root = btrfs_read_fs_root(fs_info, &key);
8585         if (IS_ERR(root)) {
8586                 fprintf(stderr, "Error reading data reloc tree\n");
8587                 ret = PTR_ERR(root);
8588                 goto out;
8589         }
8590         record_root_in_trans(trans, root);
8591         ret = btrfs_fsck_reinit_root(trans, root, 0);
8592         if (ret)
8593                 goto out;
8594         ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
8595 out:
8596         btrfs_free_path(path);
8597         return ret;
8598 }
8599
8600 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
8601                               struct btrfs_fs_info *fs_info)
8602 {
8603         u64 start = 0;
8604         int ret;
8605
8606         /*
8607          * The only reason we don't do this is because right now we're just
8608          * walking the trees we find and pinning down their bytes, we don't look
8609          * at any of the leaves.  In order to do mixed groups we'd have to check
8610          * the leaves of any fs roots and pin down the bytes for any file
8611          * extents we find.  Not hard but why do it if we don't have to?
8612          */
8613         if (btrfs_fs_incompat(fs_info, BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS)) {
8614                 fprintf(stderr, "We don't support re-initing the extent tree "
8615                         "for mixed block groups yet, please notify a btrfs "
8616                         "developer you want to do this so they can add this "
8617                         "functionality.\n");
8618                 return -EINVAL;
8619         }
8620
8621         /*
8622          * first we need to walk all of the trees except the extent tree and pin
8623          * down the bytes that are in use so we don't overwrite any existing
8624          * metadata.
8625          */
8626         ret = pin_metadata_blocks(fs_info);
8627         if (ret) {
8628                 fprintf(stderr, "error pinning down used bytes\n");
8629                 return ret;
8630         }
8631
8632         /*
8633          * Need to drop all the block groups since we're going to recreate all
8634          * of them again.
8635          */
8636         btrfs_free_block_groups(fs_info);
8637         ret = reset_block_groups(fs_info);
8638         if (ret) {
8639                 fprintf(stderr, "error resetting the block groups\n");
8640                 return ret;
8641         }
8642
8643         /* Ok we can allocate now, reinit the extent root */
8644         ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
8645         if (ret) {
8646                 fprintf(stderr, "extent root initialization failed\n");
8647                 /*
8648                  * When the transaction code is updated we should end the
8649                  * transaction, but for now progs only knows about commit so
8650                  * just return an error.
8651                  */
8652                 return ret;
8653         }
8654
8655         /*
8656          * Now we have all the in-memory block groups setup so we can make
8657          * allocations properly, and the metadata we care about is safe since we
8658          * pinned all of it above.
8659          */
8660         while (1) {
8661                 struct btrfs_block_group_cache *cache;
8662
8663                 cache = btrfs_lookup_first_block_group(fs_info, start);
8664                 if (!cache)
8665                         break;
8666                 start = cache->key.objectid + cache->key.offset;
8667                 ret = btrfs_insert_item(trans, fs_info->extent_root,
8668                                         &cache->key, &cache->item,
8669                                         sizeof(cache->item));
8670                 if (ret) {
8671                         fprintf(stderr, "Error adding block group\n");
8672                         return ret;
8673                 }
8674                 btrfs_extent_post_op(trans, fs_info->extent_root);
8675         }
8676
8677         ret = reset_balance(trans, fs_info);
8678         if (ret)
8679                 fprintf(stderr, "error reseting the pending balance\n");
8680
8681         return ret;
8682 }
8683
8684 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
8685 {
8686         struct btrfs_path *path;
8687         struct btrfs_trans_handle *trans;
8688         struct btrfs_key key;
8689         int ret;
8690
8691         printf("Recowing metadata block %llu\n", eb->start);
8692         key.objectid = btrfs_header_owner(eb);
8693         key.type = BTRFS_ROOT_ITEM_KEY;
8694         key.offset = (u64)-1;
8695
8696         root = btrfs_read_fs_root(root->fs_info, &key);
8697         if (IS_ERR(root)) {
8698                 fprintf(stderr, "Couldn't find owner root %llu\n",
8699                         key.objectid);
8700                 return PTR_ERR(root);
8701         }
8702
8703         path = btrfs_alloc_path();
8704         if (!path)
8705                 return -ENOMEM;
8706
8707         trans = btrfs_start_transaction(root, 1);
8708         if (IS_ERR(trans)) {
8709                 btrfs_free_path(path);
8710                 return PTR_ERR(trans);
8711         }
8712
8713         path->lowest_level = btrfs_header_level(eb);
8714         if (path->lowest_level)
8715                 btrfs_node_key_to_cpu(eb, &key, 0);
8716         else
8717                 btrfs_item_key_to_cpu(eb, &key, 0);
8718
8719         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8720         btrfs_commit_transaction(trans, root);
8721         btrfs_free_path(path);
8722         return ret;
8723 }
8724
8725 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
8726 {
8727         struct btrfs_path *path;
8728         struct btrfs_trans_handle *trans;
8729         struct btrfs_key key;
8730         int ret;
8731
8732         printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
8733                bad->key.type, bad->key.offset);
8734         key.objectid = bad->root_id;
8735         key.type = BTRFS_ROOT_ITEM_KEY;
8736         key.offset = (u64)-1;
8737
8738         root = btrfs_read_fs_root(root->fs_info, &key);
8739         if (IS_ERR(root)) {
8740                 fprintf(stderr, "Couldn't find owner root %llu\n",
8741                         key.objectid);
8742                 return PTR_ERR(root);
8743         }
8744
8745         path = btrfs_alloc_path();
8746         if (!path)
8747                 return -ENOMEM;
8748
8749         trans = btrfs_start_transaction(root, 1);
8750         if (IS_ERR(trans)) {
8751                 btrfs_free_path(path);
8752                 return PTR_ERR(trans);
8753         }
8754
8755         ret = btrfs_search_slot(trans, root, &bad->key, path, -1, 1);
8756         if (ret) {
8757                 if (ret > 0)
8758                         ret = 0;
8759                 goto out;
8760         }
8761         ret = btrfs_del_item(trans, root, path);
8762 out:
8763         btrfs_commit_transaction(trans, root);
8764         btrfs_free_path(path);
8765         return ret;
8766 }
8767
8768 static int zero_log_tree(struct btrfs_root *root)
8769 {
8770         struct btrfs_trans_handle *trans;
8771         int ret;
8772
8773         trans = btrfs_start_transaction(root, 1);
8774         if (IS_ERR(trans)) {
8775                 ret = PTR_ERR(trans);
8776                 return ret;
8777         }
8778         btrfs_set_super_log_root(root->fs_info->super_copy, 0);
8779         btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
8780         ret = btrfs_commit_transaction(trans, root);
8781         return ret;
8782 }
8783
8784 static int populate_csum(struct btrfs_trans_handle *trans,
8785                          struct btrfs_root *csum_root, char *buf, u64 start,
8786                          u64 len)
8787 {
8788         u64 offset = 0;
8789         u64 sectorsize;
8790         int ret = 0;
8791
8792         while (offset < len) {
8793                 sectorsize = csum_root->sectorsize;
8794                 ret = read_extent_data(csum_root, buf, start + offset,
8795                                        &sectorsize, 0);
8796                 if (ret)
8797                         break;
8798                 ret = btrfs_csum_file_block(trans, csum_root, start + len,
8799                                             start + offset, buf, sectorsize);
8800                 if (ret)
8801                         break;
8802                 offset += sectorsize;
8803         }
8804         return ret;
8805 }
8806
8807 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
8808                                       struct btrfs_root *csum_root,
8809                                       struct btrfs_root *cur_root)
8810 {
8811         struct btrfs_path *path;
8812         struct btrfs_key key;
8813         struct extent_buffer *node;
8814         struct btrfs_file_extent_item *fi;
8815         char *buf = NULL;
8816         u64 start = 0;
8817         u64 len = 0;
8818         int slot = 0;
8819         int ret = 0;
8820
8821         path = btrfs_alloc_path();
8822         if (!path)
8823                 return -ENOMEM;
8824         buf = malloc(cur_root->fs_info->csum_root->sectorsize);
8825         if (!buf) {
8826                 ret = -ENOMEM;
8827                 goto out;
8828         }
8829
8830         key.objectid = 0;
8831         key.offset = 0;
8832         key.type = 0;
8833
8834         ret = btrfs_search_slot(NULL, cur_root, &key, path, 0, 0);
8835         if (ret < 0)
8836                 goto out;
8837         /* Iterate all regular file extents and fill its csum */
8838         while (1) {
8839                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
8840
8841                 if (key.type != BTRFS_EXTENT_DATA_KEY)
8842                         goto next;
8843                 node = path->nodes[0];
8844                 slot = path->slots[0];
8845                 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
8846                 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
8847                         goto next;
8848                 start = btrfs_file_extent_disk_bytenr(node, fi);
8849                 len = btrfs_file_extent_disk_num_bytes(node, fi);
8850
8851                 ret = populate_csum(trans, csum_root, buf, start, len);
8852                 if (ret == -EEXIST)
8853                         ret = 0;
8854                 if (ret < 0)
8855                         goto out;
8856 next:
8857                 /*
8858                  * TODO: if next leaf is corrupted, jump to nearest next valid
8859                  * leaf.
8860                  */
8861                 ret = btrfs_next_item(cur_root, path);
8862                 if (ret < 0)
8863                         goto out;
8864                 if (ret > 0) {
8865                         ret = 0;
8866                         goto out;
8867                 }
8868         }
8869
8870 out:
8871         btrfs_free_path(path);
8872         free(buf);
8873         return ret;
8874 }
8875
8876 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
8877                                   struct btrfs_root *csum_root)
8878 {
8879         struct btrfs_fs_info *fs_info = csum_root->fs_info;
8880         struct btrfs_path *path;
8881         struct btrfs_root *tree_root = fs_info->tree_root;
8882         struct btrfs_root *cur_root;
8883         struct extent_buffer *node;
8884         struct btrfs_key key;
8885         int slot = 0;
8886         int ret = 0;
8887
8888         path = btrfs_alloc_path();
8889         if (!path)
8890                 return -ENOMEM;
8891
8892         key.objectid = BTRFS_FS_TREE_OBJECTID;
8893         key.offset = 0;
8894         key.type = BTRFS_ROOT_ITEM_KEY;
8895
8896         ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
8897         if (ret < 0)
8898                 goto out;
8899         if (ret > 0) {
8900                 ret = -ENOENT;
8901                 goto out;
8902         }
8903
8904         while (1) {
8905                 node = path->nodes[0];
8906                 slot = path->slots[0];
8907                 btrfs_item_key_to_cpu(node, &key, slot);
8908                 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
8909                         goto out;
8910                 if (key.type != BTRFS_ROOT_ITEM_KEY)
8911                         goto next;
8912                 if (!is_fstree(key.objectid))
8913                         goto next;
8914                 key.offset = (u64)-1;
8915
8916                 cur_root = btrfs_read_fs_root(fs_info, &key);
8917                 if (IS_ERR(cur_root) || !cur_root) {
8918                         fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
8919                                 key.objectid);
8920                         goto out;
8921                 }
8922                 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
8923                                 cur_root);
8924                 if (ret < 0)
8925                         goto out;
8926 next:
8927                 ret = btrfs_next_item(tree_root, path);
8928                 if (ret > 0) {
8929                         ret = 0;
8930                         goto out;
8931                 }
8932                 if (ret < 0)
8933                         goto out;
8934         }
8935
8936 out:
8937         btrfs_free_path(path);
8938         return ret;
8939 }
8940
8941 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
8942                                       struct btrfs_root *csum_root)
8943 {
8944         struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
8945         struct btrfs_path *path;
8946         struct btrfs_extent_item *ei;
8947         struct extent_buffer *leaf;
8948         char *buf;
8949         struct btrfs_key key;
8950         int ret;
8951
8952         path = btrfs_alloc_path();
8953         if (!path)
8954                 return -ENOMEM;
8955
8956         key.objectid = 0;
8957         key.type = BTRFS_EXTENT_ITEM_KEY;
8958         key.offset = 0;
8959
8960         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
8961         if (ret < 0) {
8962                 btrfs_free_path(path);
8963                 return ret;
8964         }
8965
8966         buf = malloc(csum_root->sectorsize);
8967         if (!buf) {
8968                 btrfs_free_path(path);
8969                 return -ENOMEM;
8970         }
8971
8972         while (1) {
8973                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8974                         ret = btrfs_next_leaf(extent_root, path);
8975                         if (ret < 0)
8976                                 break;
8977                         if (ret) {
8978                                 ret = 0;
8979                                 break;
8980                         }
8981                 }
8982                 leaf = path->nodes[0];
8983
8984                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8985                 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
8986                         path->slots[0]++;
8987                         continue;
8988                 }
8989
8990                 ei = btrfs_item_ptr(leaf, path->slots[0],
8991                                     struct btrfs_extent_item);
8992                 if (!(btrfs_extent_flags(leaf, ei) &
8993                       BTRFS_EXTENT_FLAG_DATA)) {
8994                         path->slots[0]++;
8995                         continue;
8996                 }
8997
8998                 ret = populate_csum(trans, csum_root, buf, key.objectid,
8999                                     key.offset);
9000                 if (ret)
9001                         break;
9002                 path->slots[0]++;
9003         }
9004
9005         btrfs_free_path(path);
9006         free(buf);
9007         return ret;
9008 }
9009
9010 /*
9011  * Recalculate the csum and put it into the csum tree.
9012  *
9013  * Extent tree init will wipe out all the extent info, so in that case, we
9014  * can't depend on extent tree, but use fs tree.  If search_fs_tree is set, we
9015  * will use fs/subvol trees to init the csum tree.
9016  */
9017 static int fill_csum_tree(struct btrfs_trans_handle *trans,
9018                           struct btrfs_root *csum_root,
9019                           int search_fs_tree)
9020 {
9021         if (search_fs_tree)
9022                 return fill_csum_tree_from_fs(trans, csum_root);
9023         else
9024                 return fill_csum_tree_from_extent(trans, csum_root);
9025 }
9026
9027 struct root_item_info {
9028         /* level of the root */
9029         u8 level;
9030         /* number of nodes at this level, must be 1 for a root */
9031         int node_count;
9032         u64 bytenr;
9033         u64 gen;
9034         struct cache_extent cache_extent;
9035 };
9036
9037 static struct cache_tree *roots_info_cache = NULL;
9038
9039 static void free_roots_info_cache(void)
9040 {
9041         if (!roots_info_cache)
9042                 return;
9043
9044         while (!cache_tree_empty(roots_info_cache)) {
9045                 struct cache_extent *entry;
9046                 struct root_item_info *rii;
9047
9048                 entry = first_cache_extent(roots_info_cache);
9049                 if (!entry)
9050                         break;
9051                 remove_cache_extent(roots_info_cache, entry);
9052                 rii = container_of(entry, struct root_item_info, cache_extent);
9053                 free(rii);
9054         }
9055
9056         free(roots_info_cache);
9057         roots_info_cache = NULL;
9058 }
9059
9060 static int build_roots_info_cache(struct btrfs_fs_info *info)
9061 {
9062         int ret = 0;
9063         struct btrfs_key key;
9064         struct extent_buffer *leaf;
9065         struct btrfs_path *path;
9066
9067         if (!roots_info_cache) {
9068                 roots_info_cache = malloc(sizeof(*roots_info_cache));
9069                 if (!roots_info_cache)
9070                         return -ENOMEM;
9071                 cache_tree_init(roots_info_cache);
9072         }
9073
9074         path = btrfs_alloc_path();
9075         if (!path)
9076                 return -ENOMEM;
9077
9078         key.objectid = 0;
9079         key.type = BTRFS_EXTENT_ITEM_KEY;
9080         key.offset = 0;
9081
9082         ret = btrfs_search_slot(NULL, info->extent_root, &key, path, 0, 0);
9083         if (ret < 0)
9084                 goto out;
9085         leaf = path->nodes[0];
9086
9087         while (1) {
9088                 struct btrfs_key found_key;
9089                 struct btrfs_extent_item *ei;
9090                 struct btrfs_extent_inline_ref *iref;
9091                 int slot = path->slots[0];
9092                 int type;
9093                 u64 flags;
9094                 u64 root_id;
9095                 u8 level;
9096                 struct cache_extent *entry;
9097                 struct root_item_info *rii;
9098
9099                 if (slot >= btrfs_header_nritems(leaf)) {
9100                         ret = btrfs_next_leaf(info->extent_root, path);
9101                         if (ret < 0) {
9102                                 break;
9103                         } else if (ret) {
9104                                 ret = 0;
9105                                 break;
9106                         }
9107                         leaf = path->nodes[0];
9108                         slot = path->slots[0];
9109                 }
9110
9111                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
9112
9113                 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
9114                     found_key.type != BTRFS_METADATA_ITEM_KEY)
9115                         goto next;
9116
9117                 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
9118                 flags = btrfs_extent_flags(leaf, ei);
9119
9120                 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
9121                     !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
9122                         goto next;
9123
9124                 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
9125                         iref = (struct btrfs_extent_inline_ref *)(ei + 1);
9126                         level = found_key.offset;
9127                 } else {
9128                         struct btrfs_tree_block_info *info;
9129
9130                         info = (struct btrfs_tree_block_info *)(ei + 1);
9131                         iref = (struct btrfs_extent_inline_ref *)(info + 1);
9132                         level = btrfs_tree_block_level(leaf, info);
9133                 }
9134
9135                 /*
9136                  * For a root extent, it must be of the following type and the
9137                  * first (and only one) iref in the item.
9138                  */
9139                 type = btrfs_extent_inline_ref_type(leaf, iref);
9140                 if (type != BTRFS_TREE_BLOCK_REF_KEY)
9141                         goto next;
9142
9143                 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
9144                 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
9145                 if (!entry) {
9146                         rii = malloc(sizeof(struct root_item_info));
9147                         if (!rii) {
9148                                 ret = -ENOMEM;
9149                                 goto out;
9150                         }
9151                         rii->cache_extent.start = root_id;
9152                         rii->cache_extent.size = 1;
9153                         rii->level = (u8)-1;
9154                         entry = &rii->cache_extent;
9155                         ret = insert_cache_extent(roots_info_cache, entry);
9156                         ASSERT(ret == 0);
9157                 } else {
9158                         rii = container_of(entry, struct root_item_info,
9159                                            cache_extent);
9160                 }
9161
9162                 ASSERT(rii->cache_extent.start == root_id);
9163                 ASSERT(rii->cache_extent.size == 1);
9164
9165                 if (level > rii->level || rii->level == (u8)-1) {
9166                         rii->level = level;
9167                         rii->bytenr = found_key.objectid;
9168                         rii->gen = btrfs_extent_generation(leaf, ei);
9169                         rii->node_count = 1;
9170                 } else if (level == rii->level) {
9171                         rii->node_count++;
9172                 }
9173 next:
9174                 path->slots[0]++;
9175         }
9176
9177 out:
9178         btrfs_free_path(path);
9179
9180         return ret;
9181 }
9182
9183 static int maybe_repair_root_item(struct btrfs_fs_info *info,
9184                                   struct btrfs_path *path,
9185                                   const struct btrfs_key *root_key,
9186                                   const int read_only_mode)
9187 {
9188         const u64 root_id = root_key->objectid;
9189         struct cache_extent *entry;
9190         struct root_item_info *rii;
9191         struct btrfs_root_item ri;
9192         unsigned long offset;
9193
9194         entry = lookup_cache_extent(roots_info_cache, root_id, 1);
9195         if (!entry) {
9196                 fprintf(stderr,
9197                         "Error: could not find extent items for root %llu\n",
9198                         root_key->objectid);
9199                 return -ENOENT;
9200         }
9201
9202         rii = container_of(entry, struct root_item_info, cache_extent);
9203         ASSERT(rii->cache_extent.start == root_id);
9204         ASSERT(rii->cache_extent.size == 1);
9205
9206         if (rii->node_count != 1) {
9207                 fprintf(stderr,
9208                         "Error: could not find btree root extent for root %llu\n",
9209                         root_id);
9210                 return -ENOENT;
9211         }
9212
9213         offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
9214         read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
9215
9216         if (btrfs_root_bytenr(&ri) != rii->bytenr ||
9217             btrfs_root_level(&ri) != rii->level ||
9218             btrfs_root_generation(&ri) != rii->gen) {
9219
9220                 /*
9221                  * If we're in repair mode but our caller told us to not update
9222                  * the root item, i.e. just check if it needs to be updated, don't
9223                  * print this message, since the caller will call us again shortly
9224                  * for the same root item without read only mode (the caller will
9225                  * open a transaction first).
9226                  */
9227                 if (!(read_only_mode && repair))
9228                         fprintf(stderr,
9229                                 "%sroot item for root %llu,"
9230                                 " current bytenr %llu, current gen %llu, current level %u,"
9231                                 " new bytenr %llu, new gen %llu, new level %u\n",
9232                                 (read_only_mode ? "" : "fixing "),
9233                                 root_id,
9234                                 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
9235                                 btrfs_root_level(&ri),
9236                                 rii->bytenr, rii->gen, rii->level);
9237
9238                 if (btrfs_root_generation(&ri) > rii->gen) {
9239                         fprintf(stderr,
9240                                 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
9241                                 root_id, btrfs_root_generation(&ri), rii->gen);
9242                         return -EINVAL;
9243                 }
9244
9245                 if (!read_only_mode) {
9246                         btrfs_set_root_bytenr(&ri, rii->bytenr);
9247                         btrfs_set_root_level(&ri, rii->level);
9248                         btrfs_set_root_generation(&ri, rii->gen);
9249                         write_extent_buffer(path->nodes[0], &ri,
9250                                             offset, sizeof(ri));
9251                 }
9252
9253                 return 1;
9254         }
9255
9256         return 0;
9257 }
9258
9259 /*
9260  * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
9261  * caused read-only snapshots to be corrupted if they were created at a moment
9262  * when the source subvolume/snapshot had orphan items. The issue was that the
9263  * on-disk root items became incorrect, referring to the pre orphan cleanup root
9264  * node instead of the post orphan cleanup root node.
9265  * So this function, and its callees, just detects and fixes those cases. Even
9266  * though the regression was for read-only snapshots, this function applies to
9267  * any snapshot/subvolume root.
9268  * This must be run before any other repair code - not doing it so, makes other
9269  * repair code delete or modify backrefs in the extent tree for example, which
9270  * will result in an inconsistent fs after repairing the root items.
9271  */
9272 static int repair_root_items(struct btrfs_fs_info *info)
9273 {
9274         struct btrfs_path *path = NULL;
9275         struct btrfs_key key;
9276         struct extent_buffer *leaf;
9277         struct btrfs_trans_handle *trans = NULL;
9278         int ret = 0;
9279         int bad_roots = 0;
9280         int need_trans = 0;
9281
9282         ret = build_roots_info_cache(info);
9283         if (ret)
9284                 goto out;
9285
9286         path = btrfs_alloc_path();
9287         if (!path) {
9288                 ret = -ENOMEM;
9289                 goto out;
9290         }
9291
9292         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
9293         key.type = BTRFS_ROOT_ITEM_KEY;
9294         key.offset = 0;
9295
9296 again:
9297         /*
9298          * Avoid opening and committing transactions if a leaf doesn't have
9299          * any root items that need to be fixed, so that we avoid rotating
9300          * backup roots unnecessarily.
9301          */
9302         if (need_trans) {
9303                 trans = btrfs_start_transaction(info->tree_root, 1);
9304                 if (IS_ERR(trans)) {
9305                         ret = PTR_ERR(trans);
9306                         goto out;
9307                 }
9308         }
9309
9310         ret = btrfs_search_slot(trans, info->tree_root, &key, path,
9311                                 0, trans ? 1 : 0);
9312         if (ret < 0)
9313                 goto out;
9314         leaf = path->nodes[0];
9315
9316         while (1) {
9317                 struct btrfs_key found_key;
9318
9319                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
9320                         int no_more_keys = find_next_key(path, &key);
9321
9322                         btrfs_release_path(path);
9323                         if (trans) {
9324                                 ret = btrfs_commit_transaction(trans,
9325                                                                info->tree_root);
9326                                 trans = NULL;
9327                                 if (ret < 0)
9328                                         goto out;
9329                         }
9330                         need_trans = 0;
9331                         if (no_more_keys)
9332                                 break;
9333                         goto again;
9334                 }
9335
9336                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
9337
9338                 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
9339                         goto next;
9340                 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
9341                         goto next;
9342
9343                 ret = maybe_repair_root_item(info, path, &found_key,
9344                                              trans ? 0 : 1);
9345                 if (ret < 0)
9346                         goto out;
9347                 if (ret) {
9348                         if (!trans && repair) {
9349                                 need_trans = 1;
9350                                 key = found_key;
9351                                 btrfs_release_path(path);
9352                                 goto again;
9353                         }
9354                         bad_roots++;
9355                 }
9356 next:
9357                 path->slots[0]++;
9358         }
9359         ret = 0;
9360 out:
9361         free_roots_info_cache();
9362         btrfs_free_path(path);
9363         if (trans)
9364                 btrfs_commit_transaction(trans, info->tree_root);
9365         if (ret < 0)
9366                 return ret;
9367
9368         return bad_roots;
9369 }
9370
9371 const char * const cmd_check_usage[] = {
9372         "btrfs check [options] <device>",
9373         "Check structural inegrity of a filesystem (unmounted).",
9374         "Check structural inegrity of an unmounted filesystem. Verify internal",
9375         "trees' consistency and item connectivity. In the repair mode try to",
9376         "fix the problems found.",
9377         "WARNING: the repair mode is considered dangerous",
9378         "",
9379         "-s|--super <superblock>     use this superblock copy",
9380         "-b|--backup                 use the backup root copy",
9381         "--repair                    try to repair the filesystem",
9382         "--readonly                  run in read-only mode (default)",
9383         "--init-csum-tree            create a new CRC tree",
9384         "--init-extent-tree          create a new extent tree",
9385         "--check-data-csum           verify checkums of data blocks",
9386         "-Q|--qgroup-report           print a report on qgroup consistency",
9387         "-E|--subvol-extents <subvolid>",
9388         "                            print subvolume extents and sharing state",
9389         "-r|--tree-root <bytenr>     use the given bytenr for the tree root",
9390         "-p|--progress               indicate progress",
9391         NULL
9392 };
9393
9394 int cmd_check(int argc, char **argv)
9395 {
9396         struct cache_tree root_cache;
9397         struct btrfs_root *root;
9398         struct btrfs_fs_info *info;
9399         u64 bytenr = 0;
9400         u64 subvolid = 0;
9401         u64 tree_root_bytenr = 0;
9402         char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
9403         int ret;
9404         u64 num;
9405         int init_csum_tree = 0;
9406         int readonly = 0;
9407         int qgroup_report = 0;
9408         enum btrfs_open_ctree_flags ctree_flags = OPEN_CTREE_EXCLUSIVE;
9409
9410         while(1) {
9411                 int c;
9412                 enum { OPT_REPAIR = 257, OPT_INIT_CSUM, OPT_INIT_EXTENT,
9413                         OPT_CHECK_CSUM, OPT_READONLY };
9414                 static const struct option long_options[] = {
9415                         { "super", required_argument, NULL, 's' },
9416                         { "repair", no_argument, NULL, OPT_REPAIR },
9417                         { "readonly", no_argument, NULL, OPT_READONLY },
9418                         { "init-csum-tree", no_argument, NULL, OPT_INIT_CSUM },
9419                         { "init-extent-tree", no_argument, NULL, OPT_INIT_EXTENT },
9420                         { "check-data-csum", no_argument, NULL, OPT_CHECK_CSUM },
9421                         { "backup", no_argument, NULL, 'b' },
9422                         { "subvol-extents", required_argument, NULL, 'E' },
9423                         { "qgroup-report", no_argument, NULL, 'Q' },
9424                         { "tree-root", required_argument, NULL, 'r' },
9425                         { "progress", no_argument, NULL, 'p' },
9426                         { NULL, 0, NULL, 0}
9427                 };
9428
9429                 c = getopt_long(argc, argv, "as:br:p", long_options, NULL);
9430                 if (c < 0)
9431                         break;
9432                 switch(c) {
9433                         case 'a': /* ignored */ break;
9434                         case 'b':
9435                                 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
9436                                 break;
9437                         case 's':
9438                                 num = arg_strtou64(optarg);
9439                                 if (num >= BTRFS_SUPER_MIRROR_MAX) {
9440                                         fprintf(stderr,
9441                                                 "ERROR: super mirror should be less than: %d\n",
9442                                                 BTRFS_SUPER_MIRROR_MAX);
9443                                         exit(1);
9444                                 }
9445                                 bytenr = btrfs_sb_offset(((int)num));
9446                                 printf("using SB copy %llu, bytenr %llu\n", num,
9447                                        (unsigned long long)bytenr);
9448                                 break;
9449                         case 'Q':
9450                                 qgroup_report = 1;
9451                                 break;
9452                         case 'E':
9453                                 subvolid = arg_strtou64(optarg);
9454                                 break;
9455                         case 'r':
9456                                 tree_root_bytenr = arg_strtou64(optarg);
9457                                 break;
9458                         case 'p':
9459                                 ctx.progress_enabled = true;
9460                                 break;
9461                         case '?':
9462                         case 'h':
9463                                 usage(cmd_check_usage);
9464                         case OPT_REPAIR:
9465                                 printf("enabling repair mode\n");
9466                                 repair = 1;
9467                                 ctree_flags |= OPEN_CTREE_WRITES;
9468                                 break;
9469                         case OPT_READONLY:
9470                                 readonly = 1;
9471                                 break;
9472                         case OPT_INIT_CSUM:
9473                                 printf("Creating a new CRC tree\n");
9474                                 init_csum_tree = 1;
9475                                 repair = 1;
9476                                 ctree_flags |= OPEN_CTREE_WRITES;
9477                                 break;
9478                         case OPT_INIT_EXTENT:
9479                                 init_extent_tree = 1;
9480                                 ctree_flags |= (OPEN_CTREE_WRITES |
9481                                                 OPEN_CTREE_NO_BLOCK_GROUPS);
9482                                 repair = 1;
9483                                 break;
9484                         case OPT_CHECK_CSUM:
9485                                 check_data_csum = 1;
9486                                 break;
9487                 }
9488         }
9489         argc = argc - optind;
9490
9491         if (check_argc_exact(argc, 1))
9492                 usage(cmd_check_usage);
9493
9494         if (ctx.progress_enabled) {
9495                 ctx.tp = TASK_NOTHING;
9496                 ctx.info = task_init(print_status_check, print_status_return, &ctx);
9497         }
9498
9499         /* This check is the only reason for --readonly to exist */
9500         if (readonly && repair) {
9501                 fprintf(stderr, "Repair options are not compatible with --readonly\n");
9502                 exit(1);
9503         }
9504
9505         radix_tree_init();
9506         cache_tree_init(&root_cache);
9507
9508         if((ret = check_mounted(argv[optind])) < 0) {
9509                 fprintf(stderr, "Could not check mount status: %s\n", strerror(-ret));
9510                 goto err_out;
9511         } else if(ret) {
9512                 fprintf(stderr, "%s is currently mounted. Aborting.\n", argv[optind]);
9513                 ret = -EBUSY;
9514                 goto err_out;
9515         }
9516
9517         /* only allow partial opening under repair mode */
9518         if (repair)
9519                 ctree_flags |= OPEN_CTREE_PARTIAL;
9520
9521         info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
9522                                   ctree_flags);
9523         if (!info) {
9524                 fprintf(stderr, "Couldn't open file system\n");
9525                 ret = -EIO;
9526                 goto err_out;
9527         }
9528
9529         global_info = info;
9530         root = info->fs_root;
9531
9532         /*
9533          * repair mode will force us to commit transaction which
9534          * will make us fail to load log tree when mounting.
9535          */
9536         if (repair && btrfs_super_log_root(info->super_copy)) {
9537                 ret = ask_user("repair mode will force to clear out log tree, Are you sure?");
9538                 if (!ret) {
9539                         ret = 1;
9540                         goto close_out;
9541                 }
9542                 ret = zero_log_tree(root);
9543                 if (ret) {
9544                         fprintf(stderr, "fail to zero log tree\n");
9545                         goto close_out;
9546                 }
9547         }
9548
9549         uuid_unparse(info->super_copy->fsid, uuidbuf);
9550         if (qgroup_report) {
9551                 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
9552                        uuidbuf);
9553                 ret = qgroup_verify_all(info);
9554                 if (ret == 0)
9555                         print_qgroup_report(1);
9556                 goto close_out;
9557         }
9558         if (subvolid) {
9559                 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
9560                        subvolid, argv[optind], uuidbuf);
9561                 ret = print_extent_state(info, subvolid);
9562                 goto close_out;
9563         }
9564         printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
9565
9566         if (!extent_buffer_uptodate(info->tree_root->node) ||
9567             !extent_buffer_uptodate(info->dev_root->node) ||
9568             !extent_buffer_uptodate(info->chunk_root->node)) {
9569                 fprintf(stderr, "Critical roots corrupted, unable to fsck the FS\n");
9570                 ret = -EIO;
9571                 goto close_out;
9572         }
9573
9574         if (init_extent_tree || init_csum_tree) {
9575                 struct btrfs_trans_handle *trans;
9576
9577                 trans = btrfs_start_transaction(info->extent_root, 0);
9578                 if (IS_ERR(trans)) {
9579                         fprintf(stderr, "Error starting transaction\n");
9580                         ret = PTR_ERR(trans);
9581                         goto close_out;
9582                 }
9583
9584                 if (init_extent_tree) {
9585                         printf("Creating a new extent tree\n");
9586                         ret = reinit_extent_tree(trans, info);
9587                         if (ret)
9588                                 goto close_out;
9589                 }
9590
9591                 if (init_csum_tree) {
9592                         fprintf(stderr, "Reinit crc root\n");
9593                         ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
9594                         if (ret) {
9595                                 fprintf(stderr, "crc root initialization failed\n");
9596                                 ret = -EIO;
9597                                 goto close_out;
9598                         }
9599
9600                         ret = fill_csum_tree(trans, info->csum_root,
9601                                              init_extent_tree);
9602                         if (ret) {
9603                                 fprintf(stderr, "crc refilling failed\n");
9604                                 return -EIO;
9605                         }
9606                 }
9607                 /*
9608                  * Ok now we commit and run the normal fsck, which will add
9609                  * extent entries for all of the items it finds.
9610                  */
9611                 ret = btrfs_commit_transaction(trans, info->extent_root);
9612                 if (ret)
9613                         goto close_out;
9614         }
9615         if (!extent_buffer_uptodate(info->extent_root->node)) {
9616                 fprintf(stderr, "Critical roots corrupted, unable to fsck the FS\n");
9617                 ret = -EIO;
9618                 goto close_out;
9619         }
9620         if (!extent_buffer_uptodate(info->csum_root->node)) {
9621                 fprintf(stderr, "Checksum root corrupted, rerun with --init-csum-tree option\n");
9622                 ret = -EIO;
9623                 goto close_out;
9624         }
9625
9626         if (!ctx.progress_enabled)
9627                 fprintf(stderr, "checking extents\n");
9628         ret = check_chunks_and_extents(root);
9629         if (ret)
9630                 fprintf(stderr, "Errors found in extent allocation tree or chunk allocation\n");
9631
9632         ret = repair_root_items(info);
9633         if (ret < 0)
9634                 goto close_out;
9635         if (repair) {
9636                 fprintf(stderr, "Fixed %d roots.\n", ret);
9637                 ret = 0;
9638         } else if (ret > 0) {
9639                 fprintf(stderr,
9640                        "Found %d roots with an outdated root item.\n",
9641                        ret);
9642                 fprintf(stderr,
9643                         "Please run a filesystem check with the option --repair to fix them.\n");
9644                 ret = 1;
9645                 goto close_out;
9646         }
9647
9648         if (!ctx.progress_enabled)
9649                 fprintf(stderr, "checking free space cache\n");
9650         ret = check_space_cache(root);
9651         if (ret)
9652                 goto out;
9653
9654         /*
9655          * We used to have to have these hole extents in between our real
9656          * extents so if we don't have this flag set we need to make sure there
9657          * are no gaps in the file extents for inodes, otherwise we can just
9658          * ignore it when this happens.
9659          */
9660         no_holes = btrfs_fs_incompat(root->fs_info,
9661                                      BTRFS_FEATURE_INCOMPAT_NO_HOLES);
9662         if (!ctx.progress_enabled)
9663                 fprintf(stderr, "checking fs roots\n");
9664         ret = check_fs_roots(root, &root_cache);
9665         if (ret)
9666                 goto out;
9667
9668         fprintf(stderr, "checking csums\n");
9669         ret = check_csums(root);
9670         if (ret)
9671                 goto out;
9672
9673         fprintf(stderr, "checking root refs\n");
9674         ret = check_root_refs(root, &root_cache);
9675         if (ret)
9676                 goto out;
9677
9678         while (repair && !list_empty(&root->fs_info->recow_ebs)) {
9679                 struct extent_buffer *eb;
9680
9681                 eb = list_first_entry(&root->fs_info->recow_ebs,
9682                                       struct extent_buffer, recow);
9683                 list_del_init(&eb->recow);
9684                 ret = recow_extent_buffer(root, eb);
9685                 if (ret)
9686                         break;
9687         }
9688
9689         while (!list_empty(&delete_items)) {
9690                 struct bad_item *bad;
9691
9692                 bad = list_first_entry(&delete_items, struct bad_item, list);
9693                 list_del_init(&bad->list);
9694                 if (repair)
9695                         ret = delete_bad_item(root, bad);
9696                 free(bad);
9697         }
9698
9699         if (info->quota_enabled) {
9700                 int err;
9701                 fprintf(stderr, "checking quota groups\n");
9702                 err = qgroup_verify_all(info);
9703                 if (err)
9704                         goto out;
9705         }
9706
9707         if (!list_empty(&root->fs_info->recow_ebs)) {
9708                 fprintf(stderr, "Transid errors in file system\n");
9709                 ret = 1;
9710         }
9711 out:
9712         print_qgroup_report(0);
9713         if (found_old_backref) { /*
9714                  * there was a disk format change when mixed
9715                  * backref was in testing tree. The old format
9716                  * existed about one week.
9717                  */
9718                 printf("\n * Found old mixed backref format. "
9719                        "The old format is not supported! *"
9720                        "\n * Please mount the FS in readonly mode, "
9721                        "backup data and re-format the FS. *\n\n");
9722                 ret = 1;
9723         }
9724         printf("found %llu bytes used err is %d\n",
9725                (unsigned long long)bytes_used, ret);
9726         printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
9727         printf("total tree bytes: %llu\n",
9728                (unsigned long long)total_btree_bytes);
9729         printf("total fs tree bytes: %llu\n",
9730                (unsigned long long)total_fs_tree_bytes);
9731         printf("total extent tree bytes: %llu\n",
9732                (unsigned long long)total_extent_tree_bytes);
9733         printf("btree space waste bytes: %llu\n",
9734                (unsigned long long)btree_space_waste);
9735         printf("file data blocks allocated: %llu\n referenced %llu\n",
9736                 (unsigned long long)data_bytes_allocated,
9737                 (unsigned long long)data_bytes_referenced);
9738
9739         free_root_recs_tree(&root_cache);
9740 close_out:
9741         close_ctree(root);
9742 err_out:
9743         if (ctx.progress_enabled)
9744                 task_deinit(ctx.info);
9745
9746         return ret;
9747 }