cmds-check.c

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