cmds-check.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <unistd.h>
  26 #include <getopt.h>
  27 #include <uuid/uuid.h>
  28 #include "ctree.h"
  29 #include "volumes.h"
  30 #include "repair.h"
  31 #include "disk-io.h"
  32 #include "print-tree.h"
  33 #include "task-utils.h"
  34 #include "transaction.h"
  35 #include "utils.h"
  36 #include "commands.h"
  37 #include "free-space-cache.h"
  38 #include "free-space-tree.h"
  39 #include "btrfsck.h"
  40 #include "qgroup-verify.h"
  41 #include "rbtree-utils.h"
  42 #include "backref.h"
  43 #include "kernel-shared/ulist.h"
  44 #include "hash.h"
  45 #include "help.h"
  46
  47 enum task_position {
  48         TASK_EXTENTS,
  49         TASK_FREE_SPACE,
  50         TASK_FS_ROOTS,
  51         TASK_NOTHING, /* have to be the last element */
  52 };
  53
  54 struct task_ctx {
  55         int progress_enabled;
  56         enum task_position tp;
  57
  58         struct task_info *info;
  59 };
  60
  61 static u64 bytes_used = 0;
  62 static u64 total_csum_bytes = 0;
  63 static u64 total_btree_bytes = 0;
  64 static u64 total_fs_tree_bytes = 0;
  65 static u64 total_extent_tree_bytes = 0;
  66 static u64 btree_space_waste = 0;
  67 static u64 data_bytes_allocated = 0;
  68 static u64 data_bytes_referenced = 0;
  69 static LIST_HEAD(duplicate_extents);
  70 static LIST_HEAD(delete_items);
  71 static int no_holes = 0;
  72 static int init_extent_tree = 0;
  73 static int check_data_csum = 0;
  74 static struct btrfs_fs_info *global_info;
  75 static struct task_ctx ctx = { 0 };
  76 static struct cache_tree *roots_info_cache = NULL;
  77
  78 enum btrfs_check_mode {
  79         CHECK_MODE_ORIGINAL,
  80         CHECK_MODE_LOWMEM,
  81         CHECK_MODE_UNKNOWN,
  82         CHECK_MODE_DEFAULT = CHECK_MODE_ORIGINAL
  83 };
  84
  85 static enum btrfs_check_mode check_mode = CHECK_MODE_DEFAULT;
  86
  87 struct extent_backref {
  88         struct rb_node node;
  89         unsigned int is_data:1;
  90         unsigned int found_extent_tree:1;
  91         unsigned int full_backref:1;
  92         unsigned int found_ref:1;
  93         unsigned int broken:1;
  94 };
  95
  96 static inline struct extent_backref* rb_node_to_extent_backref(struct rb_node *node)
  97 {
  98         return rb_entry(node, struct extent_backref, node);
  99 }
 100
 101 struct data_backref {
 102         struct extent_backref node;
 103         union {
 104                 u64 parent;
 105                 u64 root;
 106         };
 107         u64 owner;
 108         u64 offset;
 109         u64 disk_bytenr;
 110         u64 bytes;
 111         u64 ram_bytes;
 112         u32 num_refs;
 113         u32 found_ref;
 114 };
 115
 116 #define ROOT_DIR_ERROR          (1<<1)  /* bad ROOT_DIR */
 117 #define DIR_ITEM_MISSING        (1<<2)  /* DIR_ITEM not found */
 118 #define DIR_ITEM_MISMATCH       (1<<3)  /* DIR_ITEM found but not match */
 119 #define INODE_REF_MISSING       (1<<4)  /* INODE_REF/INODE_EXTREF not found */
 120 #define INODE_ITEM_MISSING      (1<<5)  /* INODE_ITEM not found */
 121 #define INODE_ITEM_MISMATCH     (1<<6)  /* INODE_ITEM found but not match */
 122 #define FILE_EXTENT_ERROR       (1<<7)  /* bad FILE_EXTENT */
 123 #define ODD_CSUM_ITEM           (1<<8)  /* CSUM_ITEM error */
 124 #define CSUM_ITEM_MISSING       (1<<9)  /* CSUM_ITEM not found */
 125 #define LINK_COUNT_ERROR        (1<<10) /* INODE_ITEM nlink count error */
 126 #define NBYTES_ERROR            (1<<11) /* INODE_ITEM nbytes count error */
 127 #define ISIZE_ERROR             (1<<12) /* INODE_ITEM size count error */
 128 #define ORPHAN_ITEM             (1<<13) /* INODE_ITEM no reference */
 129 #define NO_INODE_ITEM           (1<<14) /* no inode_item */
 130 #define LAST_ITEM               (1<<15) /* Complete this tree traversal */
 131 #define ROOT_REF_MISSING        (1<<16) /* ROOT_REF not found */
 132 #define ROOT_REF_MISMATCH       (1<<17) /* ROOT_REF found but not match */
 133 #define DIR_INDEX_MISSING       (1<<18) /* INODE_INDEX not found */
 134 #define DIR_INDEX_MISMATCH      (1<<19) /* INODE_INDEX found but not match */
 135 #define DIR_COUNT_AGAIN         (1<<20) /* DIR isize should be recalculated */
 136 #define BG_ACCOUNTING_ERROR     (1<<21) /* Block group accounting error */
 137
 138 static inline struct data_backref* to_data_backref(struct extent_backref *back)
 139 {
 140         return container_of(back, struct data_backref, node);
 141 }
 142
 143 static int compare_data_backref(struct rb_node *node1, struct rb_node *node2)
 144 {
 145         struct extent_backref *ext1 = rb_node_to_extent_backref(node1);
 146         struct extent_backref *ext2 = rb_node_to_extent_backref(node2);
 147         struct data_backref *back1 = to_data_backref(ext1);
 148         struct data_backref *back2 = to_data_backref(ext2);
 149
 150         WARN_ON(!ext1->is_data);
 151         WARN_ON(!ext2->is_data);
 152
 153         /* parent and root are a union, so this covers both */
 154         if (back1->parent > back2->parent)
 155                 return 1;
 156         if (back1->parent < back2->parent)
 157                 return -1;
 158
 159         /* This is a full backref and the parents match. */
 160         if (back1->node.full_backref)
 161                 return 0;
 162
 163         if (back1->owner > back2->owner)
 164                 return 1;
 165         if (back1->owner < back2->owner)
 166                 return -1;
 167
 168         if (back1->offset > back2->offset)
 169                 return 1;
 170         if (back1->offset < back2->offset)
 171                 return -1;
 172
 173         if (back1->found_ref && back2->found_ref) {
 174                 if (back1->disk_bytenr > back2->disk_bytenr)
 175                         return 1;
 176                 if (back1->disk_bytenr < back2->disk_bytenr)
 177                         return -1;
 178
 179                 if (back1->bytes > back2->bytes)
 180                         return 1;
 181                 if (back1->bytes < back2->bytes)
 182                         return -1;
 183         }
 184
 185         return 0;
 186 }
 187
 188 /*
 189  * Much like data_backref, just removed the undetermined members
 190  * and change it to use list_head.
 191  * During extent scan, it is stored in root->orphan_data_extent.
 192  * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
 193  */
 194 struct orphan_data_extent {
 195         struct list_head list;
 196         u64 root;
 197         u64 objectid;
 198         u64 offset;
 199         u64 disk_bytenr;
 200         u64 disk_len;
 201 };
 202
 203 struct tree_backref {
 204         struct extent_backref node;
 205         union {
 206                 u64 parent;
 207                 u64 root;
 208         };
 209 };
 210
 211 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
 212 {
 213         return container_of(back, struct tree_backref, node);
 214 }
 215
 216 static int compare_tree_backref(struct rb_node *node1, struct rb_node *node2)
 217 {
 218         struct extent_backref *ext1 = rb_node_to_extent_backref(node1);
 219         struct extent_backref *ext2 = rb_node_to_extent_backref(node2);
 220         struct tree_backref *back1 = to_tree_backref(ext1);
 221         struct tree_backref *back2 = to_tree_backref(ext2);
 222
 223         WARN_ON(ext1->is_data);
 224         WARN_ON(ext2->is_data);
 225
 226         /* parent and root are a union, so this covers both */
 227         if (back1->parent > back2->parent)
 228                 return 1;
 229         if (back1->parent < back2->parent)
 230                 return -1;
 231
 232         return 0;
 233 }
 234
 235 static int compare_extent_backref(struct rb_node *node1, struct rb_node *node2)
 236 {
 237         struct extent_backref *ext1 = rb_node_to_extent_backref(node1);
 238         struct extent_backref *ext2 = rb_node_to_extent_backref(node2);
 239
 240         if (ext1->is_data > ext2->is_data)
 241                 return 1;
 242
 243         if (ext1->is_data < ext2->is_data)
 244                 return -1;
 245
 246         if (ext1->full_backref > ext2->full_backref)
 247                 return 1;
 248         if (ext1->full_backref < ext2->full_backref)
 249                 return -1;
 250
 251         if (ext1->is_data)
 252                 return compare_data_backref(node1, node2);
 253         else
 254                 return compare_tree_backref(node1, node2);
 255 }
 256
 257 /* Explicit initialization for extent_record::flag_block_full_backref */
 258 enum { FLAG_UNSET = 2 };
 259
 260 struct extent_record {
 261         struct list_head backrefs;
 262         struct list_head dups;
 263         struct rb_root backref_tree;
 264         struct list_head list;
 265         struct cache_extent cache;
 266         struct btrfs_disk_key parent_key;
 267         u64 start;
 268         u64 max_size;
 269         u64 nr;
 270         u64 refs;
 271         u64 extent_item_refs;
 272         u64 generation;
 273         u64 parent_generation;
 274         u64 info_objectid;
 275         u32 num_duplicates;
 276         u8 info_level;
 277         unsigned int flag_block_full_backref:2;
 278         unsigned int found_rec:1;
 279         unsigned int content_checked:1;
 280         unsigned int owner_ref_checked:1;
 281         unsigned int is_root:1;
 282         unsigned int metadata:1;
 283         unsigned int bad_full_backref:1;
 284         unsigned int crossing_stripes:1;
 285         unsigned int wrong_chunk_type:1;
 286 };
 287
 288 static inline struct extent_record* to_extent_record(struct list_head *entry)
 289 {
 290         return container_of(entry, struct extent_record, list);
 291 }
 292
 293 struct inode_backref {
 294         struct list_head list;
 295         unsigned int found_dir_item:1;
 296         unsigned int found_dir_index:1;
 297         unsigned int found_inode_ref:1;
 298         u8 filetype;
 299         u8 ref_type;
 300         int errors;
 301         u64 dir;
 302         u64 index;
 303         u16 namelen;
 304         char name[0];
 305 };
 306
 307 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
 308 {
 309         return list_entry(entry, struct inode_backref, list);
 310 }
 311
 312 struct root_item_record {
 313         struct list_head list;
 314         u64 objectid;
 315         u64 bytenr;
 316         u64 last_snapshot;
 317         u8 level;
 318         u8 drop_level;
 319         struct btrfs_key drop_key;
 320 };
 321
 322 #define REF_ERR_NO_DIR_ITEM             (1 << 0)
 323 #define REF_ERR_NO_DIR_INDEX            (1 << 1)
 324 #define REF_ERR_NO_INODE_REF            (1 << 2)
 325 #define REF_ERR_DUP_DIR_ITEM            (1 << 3)
 326 #define REF_ERR_DUP_DIR_INDEX           (1 << 4)
 327 #define REF_ERR_DUP_INODE_REF           (1 << 5)
 328 #define REF_ERR_INDEX_UNMATCH           (1 << 6)
 329 #define REF_ERR_FILETYPE_UNMATCH        (1 << 7)
 330 #define REF_ERR_NAME_TOO_LONG           (1 << 8) // 100
 331 #define REF_ERR_NO_ROOT_REF             (1 << 9)
 332 #define REF_ERR_NO_ROOT_BACKREF         (1 << 10)
 333 #define REF_ERR_DUP_ROOT_REF            (1 << 11)
 334 #define REF_ERR_DUP_ROOT_BACKREF        (1 << 12)
 335
 336 struct file_extent_hole {
 337         struct rb_node node;
 338         u64 start;
 339         u64 len;
 340 };
 341
 342 struct inode_record {
 343         struct list_head backrefs;
 344         unsigned int checked:1;
 345         unsigned int merging:1;
 346         unsigned int found_inode_item:1;
 347         unsigned int found_dir_item:1;
 348         unsigned int found_file_extent:1;
 349         unsigned int found_csum_item:1;
 350         unsigned int some_csum_missing:1;
 351         unsigned int nodatasum:1;
 352         int errors;
 353
 354         u64 ino;
 355         u32 nlink;
 356         u32 imode;
 357         u64 isize;
 358         u64 nbytes;
 359
 360         u32 found_link;
 361         u64 found_size;
 362         u64 extent_start;
 363         u64 extent_end;
 364         struct rb_root holes;
 365         struct list_head orphan_extents;
 366
 367         u32 refs;
 368 };
 369
 370 #define I_ERR_NO_INODE_ITEM             (1 << 0)
 371 #define I_ERR_NO_ORPHAN_ITEM            (1 << 1)
 372 #define I_ERR_DUP_INODE_ITEM            (1 << 2)
 373 #define I_ERR_DUP_DIR_INDEX             (1 << 3)
 374 #define I_ERR_ODD_DIR_ITEM              (1 << 4)
 375 #define I_ERR_ODD_FILE_EXTENT           (1 << 5)
 376 #define I_ERR_BAD_FILE_EXTENT           (1 << 6)
 377 #define I_ERR_FILE_EXTENT_OVERLAP       (1 << 7)
 378 #define I_ERR_FILE_EXTENT_DISCOUNT      (1 << 8) // 100
 379 #define I_ERR_DIR_ISIZE_WRONG           (1 << 9)
 380 #define I_ERR_FILE_NBYTES_WRONG         (1 << 10) // 400
 381 #define I_ERR_ODD_CSUM_ITEM             (1 << 11)
 382 #define I_ERR_SOME_CSUM_MISSING         (1 << 12)
 383 #define I_ERR_LINK_COUNT_WRONG          (1 << 13)
 384 #define I_ERR_FILE_EXTENT_ORPHAN        (1 << 14)
 385
 386 struct root_backref {
 387         struct list_head list;
 388         unsigned int found_dir_item:1;
 389         unsigned int found_dir_index:1;
 390         unsigned int found_back_ref:1;
 391         unsigned int found_forward_ref:1;
 392         unsigned int reachable:1;
 393         int errors;
 394         u64 ref_root;
 395         u64 dir;
 396         u64 index;
 397         u16 namelen;
 398         char name[0];
 399 };
 400
 401 static inline struct root_backref* to_root_backref(struct list_head *entry)
 402 {
 403         return list_entry(entry, struct root_backref, list);
 404 }
 405
 406 struct root_record {
 407         struct list_head backrefs;
 408         struct cache_extent cache;
 409         unsigned int found_root_item:1;
 410         u64 objectid;
 411         u32 found_ref;
 412 };
 413
 414 struct ptr_node {
 415         struct cache_extent cache;
 416         void *data;
 417 };
 418
 419 struct shared_node {
 420         struct cache_extent cache;
 421         struct cache_tree root_cache;
 422         struct cache_tree inode_cache;
 423         struct inode_record *current;
 424         u32 refs;
 425 };
 426
 427 struct block_info {
 428         u64 start;
 429         u32 size;
 430 };
 431
 432 struct walk_control {
 433         struct cache_tree shared;
 434         struct shared_node *nodes[BTRFS_MAX_LEVEL];
 435         int active_node;
 436         int root_level;
 437 };
 438
 439 struct bad_item {
 440         struct btrfs_key key;
 441         u64 root_id;
 442         struct list_head list;
 443 };
 444
 445 struct extent_entry {
 446         u64 bytenr;
 447         u64 bytes;
 448         int count;
 449         int broken;
 450         struct list_head list;
 451 };
 452
 453 struct root_item_info {
 454         /* level of the root */
 455         u8 level;
 456         /* number of nodes at this level, must be 1 for a root */
 457         int node_count;
 458         u64 bytenr;
 459         u64 gen;
 460         struct cache_extent cache_extent;
 461 };
 462
 463 /*
 464  * Error bit for low memory mode check.
 465  *
 466  * Currently no caller cares about it yet.  Just internal use for error
 467  * classification.
 468  */
 469 #define BACKREF_MISSING         (1 << 0) /* Backref missing in extent tree */
 470 #define BACKREF_MISMATCH        (1 << 1) /* Backref exists but does not match */
 471 #define BYTES_UNALIGNED         (1 << 2) /* Some bytes are not aligned */
 472 #define REFERENCER_MISSING      (1 << 3) /* Referencer not found */
 473 #define REFERENCER_MISMATCH     (1 << 4) /* Referenceer found but does not match */
 474 #define CROSSING_STRIPE_BOUNDARY (1 << 4) /* For kernel scrub workaround */
 475 #define ITEM_SIZE_MISMATCH      (1 << 5) /* Bad item size */
 476 #define UNKNOWN_TYPE            (1 << 6) /* Unknown type */
 477 #define ACCOUNTING_MISMATCH     (1 << 7) /* Used space accounting error */
 478 #define CHUNK_TYPE_MISMATCH     (1 << 8)
 479
 480 static void *print_status_check(void *p)
 481 {
 482         struct task_ctx *priv = p;
 483         const char work_indicator[] = { '.', 'o', 'O', 'o' };
 484         uint32_t count = 0;
 485         static char *task_position_string[] = {
 486                 "checking extents",
 487                 "checking free space cache",
 488                 "checking fs roots",
 489         };
 490
 491         task_period_start(priv->info, 1000 /* 1s */);
 492
 493         if (priv->tp == TASK_NOTHING)
 494                 return NULL;
 495
 496         while (1) {
 497                 printf("%s [%c]\r", task_position_string[priv->tp],
 498                                 work_indicator[count % 4]);
 499                 count++;
 500                 fflush(stdout);
 501                 task_period_wait(priv->info);
 502         }
 503         return NULL;
 504 }
 505
 506 static int print_status_return(void *p)
 507 {
 508         printf("\n");
 509         fflush(stdout);
 510
 511         return 0;
 512 }
 513
 514 static enum btrfs_check_mode parse_check_mode(const char *str)
 515 {
 516         if (strcmp(str, "lowmem") == 0)
 517                 return CHECK_MODE_LOWMEM;
 518         if (strcmp(str, "orig") == 0)
 519                 return CHECK_MODE_ORIGINAL;
 520         if (strcmp(str, "original") == 0)
 521                 return CHECK_MODE_ORIGINAL;
 522
 523         return CHECK_MODE_UNKNOWN;
 524 }
 525
 526 /* Compatible function to allow reuse of old codes */
 527 static u64 first_extent_gap(struct rb_root *holes)
 528 {
 529         struct file_extent_hole *hole;
 530
 531         if (RB_EMPTY_ROOT(holes))
 532                 return (u64)-1;
 533
 534         hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
 535         return hole->start;
 536 }
 537
 538 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
 539 {
 540         struct file_extent_hole *hole1;
 541         struct file_extent_hole *hole2;
 542
 543         hole1 = rb_entry(node1, struct file_extent_hole, node);
 544         hole2 = rb_entry(node2, struct file_extent_hole, node);
 545
 546         if (hole1->start > hole2->start)
 547                 return -1;
 548         if (hole1->start < hole2->start)
 549                 return 1;
 550         /* Now hole1->start == hole2->start */
 551         if (hole1->len >= hole2->len)
 552                 /*
 553                  * Hole 1 will be merge center
 554                  * Same hole will be merged later
 555                  */
 556                 return -1;
 557         /* Hole 2 will be merge center */
 558         return 1;
 559 }
 560
 561 /*
 562  * Add a hole to the record
 563  *
 564  * This will do hole merge for copy_file_extent_holes(),
 565  * which will ensure there won't be continuous holes.
 566  */
 567 static int add_file_extent_hole(struct rb_root *holes,
 568                                 u64 start, u64 len)
 569 {
 570         struct file_extent_hole *hole;
 571         struct file_extent_hole *prev = NULL;
 572         struct file_extent_hole *next = NULL;
 573
 574         hole = malloc(sizeof(*hole));
 575         if (!hole)
 576                 return -ENOMEM;
 577         hole->start = start;
 578         hole->len = len;
 579         /* Since compare will not return 0, no -EEXIST will happen */
 580         rb_insert(holes, &hole->node, compare_hole);
 581
 582         /* simple merge with previous hole */
 583         if (rb_prev(&hole->node))
 584                 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
 585                                 node);
 586         if (prev && prev->start + prev->len >= hole->start) {
 587                 hole->len = hole->start + hole->len - prev->start;
 588                 hole->start = prev->start;
 589                 rb_erase(&prev->node, holes);
 590                 free(prev);
 591                 prev = NULL;
 592         }
 593
 594         /* iterate merge with next holes */
 595         while (1) {
 596                 if (!rb_next(&hole->node))
 597                         break;
 598                 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
 599                                         node);
 600                 if (hole->start + hole->len >= next->start) {
 601                         if (hole->start + hole->len <= next->start + next->len)
 602                                 hole->len = next->start + next->len -
 603                                             hole->start;
 604                         rb_erase(&next->node, holes);
 605                         free(next);
 606                         next = NULL;
 607                 } else
 608                         break;
 609         }
 610         return 0;
 611 }
 612
 613 static int compare_hole_range(struct rb_node *node, void *data)
 614 {
 615         struct file_extent_hole *hole;
 616         u64 start;
 617
 618         hole = (struct file_extent_hole *)data;
 619         start = hole->start;
 620
 621         hole = rb_entry(node, struct file_extent_hole, node);
 622         if (start < hole->start)
 623                 return -1;
 624         if (start >= hole->start && start < hole->start + hole->len)
 625                 return 0;
 626         return 1;
 627 }
 628
 629 /*
 630  * Delete a hole in the record
 631  *
 632  * This will do the hole split and is much restrict than add.
 633  */
 634 static int del_file_extent_hole(struct rb_root *holes,
 635                                 u64 start, u64 len)
 636 {
 637         struct file_extent_hole *hole;
 638         struct file_extent_hole tmp;
 639         u64 prev_start = 0;
 640         u64 prev_len = 0;
 641         u64 next_start = 0;
 642         u64 next_len = 0;
 643         struct rb_node *node;
 644         int have_prev = 0;
 645         int have_next = 0;
 646         int ret = 0;
 647
 648         tmp.start = start;
 649         tmp.len = len;
 650         node = rb_search(holes, &tmp, compare_hole_range, NULL);
 651         if (!node)
 652                 return -EEXIST;
 653         hole = rb_entry(node, struct file_extent_hole, node);
 654         if (start + len > hole->start + hole->len)
 655                 return -EEXIST;
 656
 657         /*
 658          * Now there will be no overlap, delete the hole and re-add the
 659          * split(s) if they exists.
 660          */
 661         if (start > hole->start) {
 662                 prev_start = hole->start;
 663                 prev_len = start - hole->start;
 664                 have_prev = 1;
 665         }
 666         if (hole->start + hole->len > start + len) {
 667                 next_start = start + len;
 668                 next_len = hole->start + hole->len - start - len;
 669                 have_next = 1;
 670         }
 671         rb_erase(node, holes);
 672         free(hole);
 673         if (have_prev) {
 674                 ret = add_file_extent_hole(holes, prev_start, prev_len);
 675                 if (ret < 0)
 676                         return ret;
 677         }
 678         if (have_next) {
 679                 ret = add_file_extent_hole(holes, next_start, next_len);
 680                 if (ret < 0)
 681                         return ret;
 682         }
 683         return 0;
 684 }
 685
 686 static int copy_file_extent_holes(struct rb_root *dst,
 687                                   struct rb_root *src)
 688 {
 689         struct file_extent_hole *hole;
 690         struct rb_node *node;
 691         int ret = 0;
 692
 693         node = rb_first(src);
 694         while (node) {
 695                 hole = rb_entry(node, struct file_extent_hole, node);
 696                 ret = add_file_extent_hole(dst, hole->start, hole->len);
 697                 if (ret)
 698                         break;
 699                 node = rb_next(node);
 700         }
 701         return ret;
 702 }
 703
 704 static void free_file_extent_holes(struct rb_root *holes)
 705 {
 706         struct rb_node *node;
 707         struct file_extent_hole *hole;
 708
 709         node = rb_first(holes);
 710         while (node) {
 711                 hole = rb_entry(node, struct file_extent_hole, node);
 712                 rb_erase(node, holes);
 713                 free(hole);
 714                 node = rb_first(holes);
 715         }
 716 }
 717
 718 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
 719
 720 static void record_root_in_trans(struct btrfs_trans_handle *trans,
 721                                  struct btrfs_root *root)
 722 {
 723         if (root->last_trans != trans->transid) {
 724                 root->track_dirty = 1;
 725                 root->last_trans = trans->transid;
 726                 root->commit_root = root->node;
 727                 extent_buffer_get(root->node);
 728         }
 729 }
 730
 731 static u8 imode_to_type(u32 imode)
 732 {
 733 #define S_SHIFT 12
 734         static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
 735                 [S_IFREG >> S_SHIFT]    = BTRFS_FT_REG_FILE,
 736                 [S_IFDIR >> S_SHIFT]    = BTRFS_FT_DIR,
 737                 [S_IFCHR >> S_SHIFT]    = BTRFS_FT_CHRDEV,
 738                 [S_IFBLK >> S_SHIFT]    = BTRFS_FT_BLKDEV,
 739                 [S_IFIFO >> S_SHIFT]    = BTRFS_FT_FIFO,
 740                 [S_IFSOCK >> S_SHIFT]   = BTRFS_FT_SOCK,
 741                 [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
 742         };
 743
 744         return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
 745 #undef S_SHIFT
 746 }
 747
 748 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
 749 {
 750         struct device_record *rec1;
 751         struct device_record *rec2;
 752
 753         rec1 = rb_entry(node1, struct device_record, node);
 754         rec2 = rb_entry(node2, struct device_record, node);
 755         if (rec1->devid > rec2->devid)
 756                 return -1;
 757         else if (rec1->devid < rec2->devid)
 758                 return 1;
 759         else
 760                 return 0;
 761 }
 762
 763 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
 764 {
 765         struct inode_record *rec;
 766         struct inode_backref *backref;
 767         struct inode_backref *orig;
 768         struct inode_backref *tmp;
 769         struct orphan_data_extent *src_orphan;
 770         struct orphan_data_extent *dst_orphan;
 771         struct rb_node *rb;
 772         size_t size;
 773         int ret;
 774
 775         rec = malloc(sizeof(*rec));
 776         if (!rec)
 777                 return ERR_PTR(-ENOMEM);
 778         memcpy(rec, orig_rec, sizeof(*rec));
 779         rec->refs = 1;
 780         INIT_LIST_HEAD(&rec->backrefs);
 781         INIT_LIST_HEAD(&rec->orphan_extents);
 782         rec->holes = RB_ROOT;
 783
 784         list_for_each_entry(orig, &orig_rec->backrefs, list) {
 785                 size = sizeof(*orig) + orig->namelen + 1;
 786                 backref = malloc(size);
 787                 if (!backref) {
 788                         ret = -ENOMEM;
 789                         goto cleanup;
 790                 }
 791                 memcpy(backref, orig, size);
 792                 list_add_tail(&backref->list, &rec->backrefs);
 793         }
 794         list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
 795                 dst_orphan = malloc(sizeof(*dst_orphan));
 796                 if (!dst_orphan) {
 797                         ret = -ENOMEM;
 798                         goto cleanup;
 799                 }
 800                 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
 801                 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
 802         }
 803         ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
 804         if (ret < 0)
 805                 goto cleanup_rb;
 806
 807         return rec;
 808
 809 cleanup_rb:
 810         rb = rb_first(&rec->holes);
 811         while (rb) {
 812                 struct file_extent_hole *hole;
 813
 814                 hole = rb_entry(rb, struct file_extent_hole, node);
 815                 rb = rb_next(rb);
 816                 free(hole);
 817         }
 818
 819 cleanup:
 820         if (!list_empty(&rec->backrefs))
 821                 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
 822                         list_del(&orig->list);
 823                         free(orig);
 824                 }
 825
 826         if (!list_empty(&rec->orphan_extents))
 827                 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
 828                         list_del(&orig->list);
 829                         free(orig);
 830                 }
 831
 832         free(rec);
 833
 834         return ERR_PTR(ret);
 835 }
 836
 837 static void print_orphan_data_extents(struct list_head *orphan_extents,
 838                                       u64 objectid)
 839 {
 840         struct orphan_data_extent *orphan;
 841
 842         if (list_empty(orphan_extents))
 843                 return;
 844         printf("The following data extent is lost in tree %llu:\n",
 845                objectid);
 846         list_for_each_entry(orphan, orphan_extents, list) {
 847                 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
 848                        orphan->objectid, orphan->offset, orphan->disk_bytenr,
 849                        orphan->disk_len);
 850         }
 851 }
 852
 853 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
 854 {
 855         u64 root_objectid = root->root_key.objectid;
 856         int errors = rec->errors;
 857
 858         if (!errors)
 859                 return;
 860         /* reloc root errors, we print its corresponding fs root objectid*/
 861         if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
 862                 root_objectid = root->root_key.offset;
 863                 fprintf(stderr, "reloc");
 864         }
 865         fprintf(stderr, "root %llu inode %llu errors %x",
 866                 (unsigned long long) root_objectid,
 867                 (unsigned long long) rec->ino, rec->errors);
 868
 869         if (errors & I_ERR_NO_INODE_ITEM)
 870                 fprintf(stderr, ", no inode item");
 871         if (errors & I_ERR_NO_ORPHAN_ITEM)
 872                 fprintf(stderr, ", no orphan item");
 873         if (errors & I_ERR_DUP_INODE_ITEM)
 874                 fprintf(stderr, ", dup inode item");
 875         if (errors & I_ERR_DUP_DIR_INDEX)
 876                 fprintf(stderr, ", dup dir index");
 877         if (errors & I_ERR_ODD_DIR_ITEM)
 878                 fprintf(stderr, ", odd dir item");
 879         if (errors & I_ERR_ODD_FILE_EXTENT)
 880                 fprintf(stderr, ", odd file extent");
 881         if (errors & I_ERR_BAD_FILE_EXTENT)
 882                 fprintf(stderr, ", bad file extent");
 883         if (errors & I_ERR_FILE_EXTENT_OVERLAP)
 884                 fprintf(stderr, ", file extent overlap");
 885         if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
 886                 fprintf(stderr, ", file extent discount");
 887         if (errors & I_ERR_DIR_ISIZE_WRONG)
 888                 fprintf(stderr, ", dir isize wrong");
 889         if (errors & I_ERR_FILE_NBYTES_WRONG)
 890                 fprintf(stderr, ", nbytes wrong");
 891         if (errors & I_ERR_ODD_CSUM_ITEM)
 892                 fprintf(stderr, ", odd csum item");
 893         if (errors & I_ERR_SOME_CSUM_MISSING)
 894                 fprintf(stderr, ", some csum missing");
 895         if (errors & I_ERR_LINK_COUNT_WRONG)
 896                 fprintf(stderr, ", link count wrong");
 897         if (errors & I_ERR_FILE_EXTENT_ORPHAN)
 898                 fprintf(stderr, ", orphan file extent");
 899         fprintf(stderr, "\n");
 900         /* Print the orphan extents if needed */
 901         if (errors & I_ERR_FILE_EXTENT_ORPHAN)
 902                 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
 903
 904         /* Print the holes if needed */
 905         if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
 906                 struct file_extent_hole *hole;
 907                 struct rb_node *node;
 908                 int found = 0;
 909
 910                 node = rb_first(&rec->holes);
 911                 fprintf(stderr, "Found file extent holes:\n");
 912                 while (node) {
 913                         found = 1;
 914                         hole = rb_entry(node, struct file_extent_hole, node);
 915                         fprintf(stderr, "\tstart: %llu, len: %llu\n",
 916                                 hole->start, hole->len);
 917                         node = rb_next(node);
 918                 }
 919                 if (!found)
 920                         fprintf(stderr, "\tstart: 0, len: %llu\n",
 921                                 round_up(rec->isize,
 922                                          root->fs_info->sectorsize));
 923         }
 924 }
 925
 926 static void print_ref_error(int errors)
 927 {
 928         if (errors & REF_ERR_NO_DIR_ITEM)
 929                 fprintf(stderr, ", no dir item");
 930         if (errors & REF_ERR_NO_DIR_INDEX)
 931                 fprintf(stderr, ", no dir index");
 932         if (errors & REF_ERR_NO_INODE_REF)
 933                 fprintf(stderr, ", no inode ref");
 934         if (errors & REF_ERR_DUP_DIR_ITEM)
 935                 fprintf(stderr, ", dup dir item");
 936         if (errors & REF_ERR_DUP_DIR_INDEX)
 937                 fprintf(stderr, ", dup dir index");
 938         if (errors & REF_ERR_DUP_INODE_REF)
 939                 fprintf(stderr, ", dup inode ref");
 940         if (errors & REF_ERR_INDEX_UNMATCH)
 941                 fprintf(stderr, ", index mismatch");
 942         if (errors & REF_ERR_FILETYPE_UNMATCH)
 943                 fprintf(stderr, ", filetype mismatch");
 944         if (errors & REF_ERR_NAME_TOO_LONG)
 945                 fprintf(stderr, ", name too long");
 946         if (errors & REF_ERR_NO_ROOT_REF)
 947                 fprintf(stderr, ", no root ref");
 948         if (errors & REF_ERR_NO_ROOT_BACKREF)
 949                 fprintf(stderr, ", no root backref");
 950         if (errors & REF_ERR_DUP_ROOT_REF)
 951                 fprintf(stderr, ", dup root ref");
 952         if (errors & REF_ERR_DUP_ROOT_BACKREF)
 953                 fprintf(stderr, ", dup root backref");
 954         fprintf(stderr, "\n");
 955 }
 956
 957 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
 958                                           u64 ino, int mod)
 959 {
 960         struct ptr_node *node;
 961         struct cache_extent *cache;
 962         struct inode_record *rec = NULL;
 963         int ret;
 964
 965         cache = lookup_cache_extent(inode_cache, ino, 1);
 966         if (cache) {
 967                 node = container_of(cache, struct ptr_node, cache);
 968                 rec = node->data;
 969                 if (mod && rec->refs > 1) {
 970                         node->data = clone_inode_rec(rec);
 971                         if (IS_ERR(node->data))
 972                                 return node->data;
 973                         rec->refs--;
 974                         rec = node->data;
 975                 }
 976         } else if (mod) {
 977                 rec = calloc(1, sizeof(*rec));
 978                 if (!rec)
 979                         return ERR_PTR(-ENOMEM);
 980                 rec->ino = ino;
 981                 rec->extent_start = (u64)-1;
 982                 rec->refs = 1;
 983                 INIT_LIST_HEAD(&rec->backrefs);
 984                 INIT_LIST_HEAD(&rec->orphan_extents);
 985                 rec->holes = RB_ROOT;
 986
 987                 node = malloc(sizeof(*node));
 988                 if (!node) {
 989                         free(rec);
 990                         return ERR_PTR(-ENOMEM);
 991                 }
 992                 node->cache.start = ino;
 993                 node->cache.size = 1;
 994                 node->data = rec;
 995
 996                 if (ino == BTRFS_FREE_INO_OBJECTID)
 997                         rec->found_link = 1;
 998
 999                 ret = insert_cache_extent(inode_cache, &node->cache);
1000                 if (ret)
1001                         return ERR_PTR(-EEXIST);
1002         }
1003         return rec;
1004 }
1005
1006 static void free_orphan_data_extents(struct list_head *orphan_extents)
1007 {
1008         struct orphan_data_extent *orphan;
1009
1010         while (!list_empty(orphan_extents)) {
1011                 orphan = list_entry(orphan_extents->next,
1012                                     struct orphan_data_extent, list);
1013                 list_del(&orphan->list);
1014                 free(orphan);
1015         }
1016 }
1017
1018 static void free_inode_rec(struct inode_record *rec)
1019 {
1020         struct inode_backref *backref;
1021
1022         if (--rec->refs > 0)
1023                 return;
1024
1025         while (!list_empty(&rec->backrefs)) {
1026                 backref = to_inode_backref(rec->backrefs.next);
1027                 list_del(&backref->list);
1028                 free(backref);
1029         }
1030         free_orphan_data_extents(&rec->orphan_extents);
1031         free_file_extent_holes(&rec->holes);
1032         free(rec);
1033 }
1034
1035 static int can_free_inode_rec(struct inode_record *rec)
1036 {
1037         if (!rec->errors && rec->checked && rec->found_inode_item &&
1038             rec->nlink == rec->found_link && list_empty(&rec->backrefs))
1039                 return 1;
1040         return 0;
1041 }
1042
1043 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
1044                                  struct inode_record *rec)
1045 {
1046         struct cache_extent *cache;
1047         struct inode_backref *tmp, *backref;
1048         struct ptr_node *node;
1049         u8 filetype;
1050
1051         if (!rec->found_inode_item)
1052                 return;
1053
1054         filetype = imode_to_type(rec->imode);
1055         list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
1056                 if (backref->found_dir_item && backref->found_dir_index) {
1057                         if (backref->filetype != filetype)
1058                                 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1059                         if (!backref->errors && backref->found_inode_ref &&
1060                             rec->nlink == rec->found_link) {
1061                                 list_del(&backref->list);
1062                                 free(backref);
1063                         }
1064                 }
1065         }
1066
1067         if (!rec->checked || rec->merging)
1068                 return;
1069
1070         if (S_ISDIR(rec->imode)) {
1071                 if (rec->found_size != rec->isize)
1072                         rec->errors |= I_ERR_DIR_ISIZE_WRONG;
1073                 if (rec->found_file_extent)
1074                         rec->errors |= I_ERR_ODD_FILE_EXTENT;
1075         } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
1076                 if (rec->found_dir_item)
1077                         rec->errors |= I_ERR_ODD_DIR_ITEM;
1078                 if (rec->found_size != rec->nbytes)
1079                         rec->errors |= I_ERR_FILE_NBYTES_WRONG;
1080                 if (rec->nlink > 0 && !no_holes &&
1081                     (rec->extent_end < rec->isize ||
1082                      first_extent_gap(&rec->holes) < rec->isize))
1083                         rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
1084         }
1085
1086         if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
1087                 if (rec->found_csum_item && rec->nodatasum)
1088                         rec->errors |= I_ERR_ODD_CSUM_ITEM;
1089                 if (rec->some_csum_missing && !rec->nodatasum)
1090                         rec->errors |= I_ERR_SOME_CSUM_MISSING;
1091         }
1092
1093         BUG_ON(rec->refs != 1);
1094         if (can_free_inode_rec(rec)) {
1095                 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
1096                 node = container_of(cache, struct ptr_node, cache);
1097                 BUG_ON(node->data != rec);
1098                 remove_cache_extent(inode_cache, &node->cache);
1099                 free(node);
1100                 free_inode_rec(rec);
1101         }
1102 }
1103
1104 static int check_orphan_item(struct btrfs_root *root, u64 ino)
1105 {
1106         struct btrfs_path path;
1107         struct btrfs_key key;
1108         int ret;
1109
1110         key.objectid = BTRFS_ORPHAN_OBJECTID;
1111         key.type = BTRFS_ORPHAN_ITEM_KEY;
1112         key.offset = ino;
1113
1114         btrfs_init_path(&path);
1115         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1116         btrfs_release_path(&path);
1117         if (ret > 0)
1118                 ret = -ENOENT;
1119         return ret;
1120 }
1121
1122 static int process_inode_item(struct extent_buffer *eb,
1123                               int slot, struct btrfs_key *key,
1124                               struct shared_node *active_node)
1125 {
1126         struct inode_record *rec;
1127         struct btrfs_inode_item *item;
1128
1129         rec = active_node->current;
1130         BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1131         if (rec->found_inode_item) {
1132                 rec->errors |= I_ERR_DUP_INODE_ITEM;
1133                 return 1;
1134         }
1135         item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
1136         rec->nlink = btrfs_inode_nlink(eb, item);
1137         rec->isize = btrfs_inode_size(eb, item);
1138         rec->nbytes = btrfs_inode_nbytes(eb, item);
1139         rec->imode = btrfs_inode_mode(eb, item);
1140         if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
1141                 rec->nodatasum = 1;
1142         rec->found_inode_item = 1;
1143         if (rec->nlink == 0)
1144                 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
1145         maybe_free_inode_rec(&active_node->inode_cache, rec);
1146         return 0;
1147 }
1148
1149 static struct inode_backref *get_inode_backref(struct inode_record *rec,
1150                                                 const char *name,
1151                                                 int namelen, u64 dir)
1152 {
1153         struct inode_backref *backref;
1154
1155         list_for_each_entry(backref, &rec->backrefs, list) {
1156                 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
1157                         break;
1158                 if (backref->dir != dir || backref->namelen != namelen)
1159                         continue;
1160                 if (memcmp(name, backref->name, namelen))
1161                         continue;
1162                 return backref;
1163         }
1164
1165         backref = malloc(sizeof(*backref) + namelen + 1);
1166         if (!backref)
1167                 return NULL;
1168         memset(backref, 0, sizeof(*backref));
1169         backref->dir = dir;
1170         backref->namelen = namelen;
1171         memcpy(backref->name, name, namelen);
1172         backref->name[namelen] = '\0';
1173         list_add_tail(&backref->list, &rec->backrefs);
1174         return backref;
1175 }
1176
1177 static int add_inode_backref(struct cache_tree *inode_cache,
1178                              u64 ino, u64 dir, u64 index,
1179                              const char *name, int namelen,
1180                              u8 filetype, u8 itemtype, int errors)
1181 {
1182         struct inode_record *rec;
1183         struct inode_backref *backref;
1184
1185         rec = get_inode_rec(inode_cache, ino, 1);
1186         BUG_ON(IS_ERR(rec));
1187         backref = get_inode_backref(rec, name, namelen, dir);
1188         BUG_ON(!backref);
1189         if (errors)
1190                 backref->errors |= errors;
1191         if (itemtype == BTRFS_DIR_INDEX_KEY) {
1192                 if (backref->found_dir_index)
1193                         backref->errors |= REF_ERR_DUP_DIR_INDEX;
1194                 if (backref->found_inode_ref && backref->index != index)
1195                         backref->errors |= REF_ERR_INDEX_UNMATCH;
1196                 if (backref->found_dir_item && backref->filetype != filetype)
1197                         backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1198
1199                 backref->index = index;
1200                 backref->filetype = filetype;
1201                 backref->found_dir_index = 1;
1202         } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1203                 rec->found_link++;
1204                 if (backref->found_dir_item)
1205                         backref->errors |= REF_ERR_DUP_DIR_ITEM;
1206                 if (backref->found_dir_index && backref->filetype != filetype)
1207                         backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1208
1209                 backref->filetype = filetype;
1210                 backref->found_dir_item = 1;
1211         } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1212                    (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1213                 if (backref->found_inode_ref)
1214                         backref->errors |= REF_ERR_DUP_INODE_REF;
1215                 if (backref->found_dir_index && backref->index != index)
1216                         backref->errors |= REF_ERR_INDEX_UNMATCH;
1217                 else
1218                         backref->index = index;
1219
1220                 backref->ref_type = itemtype;
1221                 backref->found_inode_ref = 1;
1222         } else {
1223                 BUG_ON(1);
1224         }
1225
1226         maybe_free_inode_rec(inode_cache, rec);
1227         return 0;
1228 }
1229
1230 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1231                             struct cache_tree *dst_cache)
1232 {
1233         struct inode_backref *backref;
1234         u32 dir_count = 0;
1235         int ret = 0;
1236
1237         dst->merging = 1;
1238         list_for_each_entry(backref, &src->backrefs, list) {
1239                 if (backref->found_dir_index) {
1240                         add_inode_backref(dst_cache, dst->ino, backref->dir,
1241                                         backref->index, backref->name,
1242                                         backref->namelen, backref->filetype,
1243                                         BTRFS_DIR_INDEX_KEY, backref->errors);
1244                 }
1245                 if (backref->found_dir_item) {
1246                         dir_count++;
1247                         add_inode_backref(dst_cache, dst->ino,
1248                                         backref->dir, 0, backref->name,
1249                                         backref->namelen, backref->filetype,
1250                                         BTRFS_DIR_ITEM_KEY, backref->errors);
1251                 }
1252                 if (backref->found_inode_ref) {
1253                         add_inode_backref(dst_cache, dst->ino,
1254                                         backref->dir, backref->index,
1255                                         backref->name, backref->namelen, 0,
1256                                         backref->ref_type, backref->errors);
1257                 }
1258         }
1259
1260         if (src->found_dir_item)
1261                 dst->found_dir_item = 1;
1262         if (src->found_file_extent)
1263                 dst->found_file_extent = 1;
1264         if (src->found_csum_item)
1265                 dst->found_csum_item = 1;
1266         if (src->some_csum_missing)
1267                 dst->some_csum_missing = 1;
1268         if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1269                 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1270                 if (ret < 0)
1271                         return ret;
1272         }
1273
1274         BUG_ON(src->found_link < dir_count);
1275         dst->found_link += src->found_link - dir_count;
1276         dst->found_size += src->found_size;
1277         if (src->extent_start != (u64)-1) {
1278                 if (dst->extent_start == (u64)-1) {
1279                         dst->extent_start = src->extent_start;
1280                         dst->extent_end = src->extent_end;
1281                 } else {
1282                         if (dst->extent_end > src->extent_start)
1283                                 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1284                         else if (dst->extent_end < src->extent_start) {
1285                                 ret = add_file_extent_hole(&dst->holes,
1286                                         dst->extent_end,
1287                                         src->extent_start - dst->extent_end);
1288                         }
1289                         if (dst->extent_end < src->extent_end)
1290                                 dst->extent_end = src->extent_end;
1291                 }
1292         }
1293
1294         dst->errors |= src->errors;
1295         if (src->found_inode_item) {
1296                 if (!dst->found_inode_item) {
1297                         dst->nlink = src->nlink;
1298                         dst->isize = src->isize;
1299                         dst->nbytes = src->nbytes;
1300                         dst->imode = src->imode;
1301                         dst->nodatasum = src->nodatasum;
1302                         dst->found_inode_item = 1;
1303                 } else {
1304                         dst->errors |= I_ERR_DUP_INODE_ITEM;
1305                 }
1306         }
1307         dst->merging = 0;
1308
1309         return 0;
1310 }
1311
1312 static int splice_shared_node(struct shared_node *src_node,
1313                               struct shared_node *dst_node)
1314 {
1315         struct cache_extent *cache;
1316         struct ptr_node *node, *ins;
1317         struct cache_tree *src, *dst;
1318         struct inode_record *rec, *conflict;
1319         u64 current_ino = 0;
1320         int splice = 0;
1321         int ret;
1322
1323         if (--src_node->refs == 0)
1324                 splice = 1;
1325         if (src_node->current)
1326                 current_ino = src_node->current->ino;
1327
1328         src = &src_node->root_cache;
1329         dst = &dst_node->root_cache;
1330 again:
1331         cache = search_cache_extent(src, 0);
1332         while (cache) {
1333                 node = container_of(cache, struct ptr_node, cache);
1334                 rec = node->data;
1335                 cache = next_cache_extent(cache);
1336
1337                 if (splice) {
1338                         remove_cache_extent(src, &node->cache);
1339                         ins = node;
1340                 } else {
1341                         ins = malloc(sizeof(*ins));
1342                         BUG_ON(!ins);
1343                         ins->cache.start = node->cache.start;
1344                         ins->cache.size = node->cache.size;
1345                         ins->data = rec;
1346                         rec->refs++;
1347                 }
1348                 ret = insert_cache_extent(dst, &ins->cache);
1349                 if (ret == -EEXIST) {
1350                         conflict = get_inode_rec(dst, rec->ino, 1);
1351                         BUG_ON(IS_ERR(conflict));
1352                         merge_inode_recs(rec, conflict, dst);
1353                         if (rec->checked) {
1354                                 conflict->checked = 1;
1355                                 if (dst_node->current == conflict)
1356                                         dst_node->current = NULL;
1357                         }
1358                         maybe_free_inode_rec(dst, conflict);
1359                         free_inode_rec(rec);
1360                         free(ins);
1361                 } else {
1362                         BUG_ON(ret);
1363                 }
1364         }
1365
1366         if (src == &src_node->root_cache) {
1367                 src = &src_node->inode_cache;
1368                 dst = &dst_node->inode_cache;
1369                 goto again;
1370         }
1371
1372         if (current_ino > 0 && (!dst_node->current ||
1373             current_ino > dst_node->current->ino)) {
1374                 if (dst_node->current) {
1375                         dst_node->current->checked = 1;
1376                         maybe_free_inode_rec(dst, dst_node->current);
1377                 }
1378                 dst_node->current = get_inode_rec(dst, current_ino, 1);
1379                 BUG_ON(IS_ERR(dst_node->current));
1380         }
1381         return 0;
1382 }
1383
1384 static void free_inode_ptr(struct cache_extent *cache)
1385 {
1386         struct ptr_node *node;
1387         struct inode_record *rec;
1388
1389         node = container_of(cache, struct ptr_node, cache);
1390         rec = node->data;
1391         free_inode_rec(rec);
1392         free(node);
1393 }
1394
1395 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1396
1397 static struct shared_node *find_shared_node(struct cache_tree *shared,
1398                                             u64 bytenr)
1399 {
1400         struct cache_extent *cache;
1401         struct shared_node *node;
1402
1403         cache = lookup_cache_extent(shared, bytenr, 1);
1404         if (cache) {
1405                 node = container_of(cache, struct shared_node, cache);
1406                 return node;
1407         }
1408         return NULL;
1409 }
1410
1411 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1412 {
1413         int ret;
1414         struct shared_node *node;
1415
1416         node = calloc(1, sizeof(*node));
1417         if (!node)
1418                 return -ENOMEM;
1419         node->cache.start = bytenr;
1420         node->cache.size = 1;
1421         cache_tree_init(&node->root_cache);
1422         cache_tree_init(&node->inode_cache);
1423         node->refs = refs;
1424
1425         ret = insert_cache_extent(shared, &node->cache);
1426
1427         return ret;
1428 }
1429
1430 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1431                              struct walk_control *wc, int level)
1432 {
1433         struct shared_node *node;
1434         struct shared_node *dest;
1435         int ret;
1436
1437         if (level == wc->active_node)
1438                 return 0;
1439
1440         BUG_ON(wc->active_node <= level);
1441         node = find_shared_node(&wc->shared, bytenr);
1442         if (!node) {
1443                 ret = add_shared_node(&wc->shared, bytenr, refs);
1444                 BUG_ON(ret);
1445                 node = find_shared_node(&wc->shared, bytenr);
1446                 wc->nodes[level] = node;
1447                 wc->active_node = level;
1448                 return 0;
1449         }
1450
1451         if (wc->root_level == wc->active_node &&
1452             btrfs_root_refs(&root->root_item) == 0) {
1453                 if (--node->refs == 0) {
1454                         free_inode_recs_tree(&node->root_cache);
1455                         free_inode_recs_tree(&node->inode_cache);
1456                         remove_cache_extent(&wc->shared, &node->cache);
1457                         free(node);
1458                 }
1459                 return 1;
1460         }
1461
1462         dest = wc->nodes[wc->active_node];
1463         splice_shared_node(node, dest);
1464         if (node->refs == 0) {
1465                 remove_cache_extent(&wc->shared, &node->cache);
1466                 free(node);
1467         }
1468         return 1;
1469 }
1470
1471 static int leave_shared_node(struct btrfs_root *root,
1472                              struct walk_control *wc, int level)
1473 {
1474         struct shared_node *node;
1475         struct shared_node *dest;
1476         int i;
1477
1478         if (level == wc->root_level)
1479                 return 0;
1480
1481         for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1482                 if (wc->nodes[i])
1483                         break;
1484         }
1485         BUG_ON(i >= BTRFS_MAX_LEVEL);
1486
1487         node = wc->nodes[wc->active_node];
1488         wc->nodes[wc->active_node] = NULL;
1489         wc->active_node = i;
1490
1491         dest = wc->nodes[wc->active_node];
1492         if (wc->active_node < wc->root_level ||
1493             btrfs_root_refs(&root->root_item) > 0) {
1494                 BUG_ON(node->refs <= 1);
1495                 splice_shared_node(node, dest);
1496         } else {
1497                 BUG_ON(node->refs < 2);
1498                 node->refs--;
1499         }
1500         return 0;
1501 }
1502
1503 /*
1504  * Returns:
1505  * < 0 - on error
1506  * 1   - if the root with id child_root_id is a child of root parent_root_id
1507  * 0   - if the root child_root_id isn't a child of the root parent_root_id but
1508  *       has other root(s) as parent(s)
1509  * 2   - if the root child_root_id doesn't have any parent roots
1510  */
1511 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1512                          u64 child_root_id)
1513 {
1514         struct btrfs_path path;
1515         struct btrfs_key key;
1516         struct extent_buffer *leaf;
1517         int has_parent = 0;
1518         int ret;
1519
1520         btrfs_init_path(&path);
1521
1522         key.objectid = parent_root_id;
1523         key.type = BTRFS_ROOT_REF_KEY;
1524         key.offset = child_root_id;
1525         ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1526                                 0, 0);
1527         if (ret < 0)
1528                 return ret;
1529         btrfs_release_path(&path);
1530         if (!ret)
1531                 return 1;
1532
1533         key.objectid = child_root_id;
1534         key.type = BTRFS_ROOT_BACKREF_KEY;
1535         key.offset = 0;
1536         ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1537                                 0, 0);
1538         if (ret < 0)
1539                 goto out;
1540
1541         while (1) {
1542                 leaf = path.nodes[0];
1543                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1544                         ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1545                         if (ret)
1546                                 break;
1547                         leaf = path.nodes[0];
1548                 }
1549
1550                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1551                 if (key.objectid != child_root_id ||
1552                     key.type != BTRFS_ROOT_BACKREF_KEY)
1553                         break;
1554
1555                 has_parent = 1;
1556
1557                 if (key.offset == parent_root_id) {
1558                         btrfs_release_path(&path);
1559                         return 1;
1560                 }
1561
1562                 path.slots[0]++;
1563         }
1564 out:
1565         btrfs_release_path(&path);
1566         if (ret < 0)
1567                 return ret;
1568         return has_parent ? 0 : 2;
1569 }
1570
1571 static int process_dir_item(struct extent_buffer *eb,
1572                             int slot, struct btrfs_key *key,
1573                             struct shared_node *active_node)
1574 {
1575         u32 total;
1576         u32 cur = 0;
1577         u32 len;
1578         u32 name_len;
1579         u32 data_len;
1580         int error;
1581         int nritems = 0;
1582         u8 filetype;
1583         struct btrfs_dir_item *di;
1584         struct inode_record *rec;
1585         struct cache_tree *root_cache;
1586         struct cache_tree *inode_cache;
1587         struct btrfs_key location;
1588         char namebuf[BTRFS_NAME_LEN];
1589
1590         root_cache = &active_node->root_cache;
1591         inode_cache = &active_node->inode_cache;
1592         rec = active_node->current;
1593         rec->found_dir_item = 1;
1594
1595         di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1596         total = btrfs_item_size_nr(eb, slot);
1597         while (cur < total) {
1598                 nritems++;
1599                 btrfs_dir_item_key_to_cpu(eb, di, &location);
1600                 name_len = btrfs_dir_name_len(eb, di);
1601                 data_len = btrfs_dir_data_len(eb, di);
1602                 filetype = btrfs_dir_type(eb, di);
1603
1604                 rec->found_size += name_len;
1605                 if (cur + sizeof(*di) + name_len > total ||
1606                     name_len > BTRFS_NAME_LEN) {
1607                         error = REF_ERR_NAME_TOO_LONG;
1608
1609                         if (cur + sizeof(*di) > total)
1610                                 break;
1611                         len = min_t(u32, total - cur - sizeof(*di),
1612                                     BTRFS_NAME_LEN);
1613                 } else {
1614                         len = name_len;
1615                         error = 0;
1616                 }
1617
1618                 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1619
1620                 if (key->type == BTRFS_DIR_ITEM_KEY &&
1621                     key->offset != btrfs_name_hash(namebuf, len)) {
1622                         rec->errors |= I_ERR_ODD_DIR_ITEM;
1623                         error("DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
1624                         key->objectid, key->offset, namebuf, len, filetype,
1625                         key->offset, btrfs_name_hash(namebuf, len));
1626                 }
1627
1628                 if (location.type == BTRFS_INODE_ITEM_KEY) {
1629                         add_inode_backref(inode_cache, location.objectid,
1630                                           key->objectid, key->offset, namebuf,
1631                                           len, filetype, key->type, error);
1632                 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1633                         add_inode_backref(root_cache, location.objectid,
1634                                           key->objectid, key->offset,
1635                                           namebuf, len, filetype,
1636                                           key->type, error);
1637                 } else {
1638                         fprintf(stderr, "invalid location in dir item %u\n",
1639                                 location.type);
1640                         add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1641                                           key->objectid, key->offset, namebuf,
1642                                           len, filetype, key->type, error);
1643                 }
1644
1645                 len = sizeof(*di) + name_len + data_len;
1646                 di = (struct btrfs_dir_item *)((char *)di + len);
1647                 cur += len;
1648         }
1649         if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1650                 rec->errors |= I_ERR_DUP_DIR_INDEX;
1651
1652         return 0;
1653 }
1654
1655 static int process_inode_ref(struct extent_buffer *eb,
1656                              int slot, struct btrfs_key *key,
1657                              struct shared_node *active_node)
1658 {
1659         u32 total;
1660         u32 cur = 0;
1661         u32 len;
1662         u32 name_len;
1663         u64 index;
1664         int error;
1665         struct cache_tree *inode_cache;
1666         struct btrfs_inode_ref *ref;
1667         char namebuf[BTRFS_NAME_LEN];
1668
1669         inode_cache = &active_node->inode_cache;
1670
1671         ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1672         total = btrfs_item_size_nr(eb, slot);
1673         while (cur < total) {
1674                 name_len = btrfs_inode_ref_name_len(eb, ref);
1675                 index = btrfs_inode_ref_index(eb, ref);
1676
1677                 /* inode_ref + namelen should not cross item boundary */
1678                 if (cur + sizeof(*ref) + name_len > total ||
1679                     name_len > BTRFS_NAME_LEN) {
1680                         if (total < cur + sizeof(*ref))
1681                                 break;
1682
1683                         /* Still try to read out the remaining part */
1684                         len = min_t(u32, total - cur - sizeof(*ref),
1685                                     BTRFS_NAME_LEN);
1686                         error = REF_ERR_NAME_TOO_LONG;
1687                 } else {
1688                         len = name_len;
1689                         error = 0;
1690                 }
1691
1692                 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1693                 add_inode_backref(inode_cache, key->objectid, key->offset,
1694                                   index, namebuf, len, 0, key->type, error);
1695
1696                 len = sizeof(*ref) + name_len;
1697                 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1698                 cur += len;
1699         }
1700         return 0;
1701 }
1702
1703 static int process_inode_extref(struct extent_buffer *eb,
1704                                 int slot, struct btrfs_key *key,
1705                                 struct shared_node *active_node)
1706 {
1707         u32 total;
1708         u32 cur = 0;
1709         u32 len;
1710         u32 name_len;
1711         u64 index;
1712         u64 parent;
1713         int error;
1714         struct cache_tree *inode_cache;
1715         struct btrfs_inode_extref *extref;
1716         char namebuf[BTRFS_NAME_LEN];
1717
1718         inode_cache = &active_node->inode_cache;
1719
1720         extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1721         total = btrfs_item_size_nr(eb, slot);
1722         while (cur < total) {
1723                 name_len = btrfs_inode_extref_name_len(eb, extref);
1724                 index = btrfs_inode_extref_index(eb, extref);
1725                 parent = btrfs_inode_extref_parent(eb, extref);
1726                 if (name_len <= BTRFS_NAME_LEN) {
1727                         len = name_len;
1728                         error = 0;
1729                 } else {
1730                         len = BTRFS_NAME_LEN;
1731                         error = REF_ERR_NAME_TOO_LONG;
1732                 }
1733                 read_extent_buffer(eb, namebuf,
1734                                    (unsigned long)(extref + 1), len);
1735                 add_inode_backref(inode_cache, key->objectid, parent,
1736                                   index, namebuf, len, 0, key->type, error);
1737
1738                 len = sizeof(*extref) + name_len;
1739                 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1740                 cur += len;
1741         }
1742         return 0;
1743
1744 }
1745
1746 static int count_csum_range(struct btrfs_root *root, u64 start,
1747                             u64 len, u64 *found)
1748 {
1749         struct btrfs_key key;
1750         struct btrfs_path path;
1751         struct extent_buffer *leaf;
1752         int ret;
1753         size_t size;
1754         *found = 0;
1755         u64 csum_end;
1756         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1757
1758         btrfs_init_path(&path);
1759
1760         key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1761         key.offset = start;
1762         key.type = BTRFS_EXTENT_CSUM_KEY;
1763
1764         ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1765                                 &key, &path, 0, 0);
1766         if (ret < 0)
1767                 goto out;
1768         if (ret > 0 && path.slots[0] > 0) {
1769                 leaf = path.nodes[0];
1770                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1771                 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1772                     key.type == BTRFS_EXTENT_CSUM_KEY)
1773                         path.slots[0]--;
1774         }
1775
1776         while (len > 0) {
1777                 leaf = path.nodes[0];
1778                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1779                         ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1780                         if (ret > 0)
1781                                 break;
1782                         else if (ret < 0)
1783                                 goto out;
1784                         leaf = path.nodes[0];
1785                 }
1786
1787                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1788                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1789                     key.type != BTRFS_EXTENT_CSUM_KEY)
1790                         break;
1791
1792                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1793                 if (key.offset >= start + len)
1794                         break;
1795
1796                 if (key.offset > start)
1797                         start = key.offset;
1798
1799                 size = btrfs_item_size_nr(leaf, path.slots[0]);
1800                 csum_end = key.offset + (size / csum_size) *
1801                            root->fs_info->sectorsize;
1802                 if (csum_end > start) {
1803                         size = min(csum_end - start, len);
1804                         len -= size;
1805                         start += size;
1806                         *found += size;
1807                 }
1808
1809                 path.slots[0]++;
1810         }
1811 out:
1812         btrfs_release_path(&path);
1813         if (ret < 0)
1814                 return ret;
1815         return 0;
1816 }
1817
1818 static int process_file_extent(struct btrfs_root *root,
1819                                 struct extent_buffer *eb,
1820                                 int slot, struct btrfs_key *key,
1821                                 struct shared_node *active_node)
1822 {
1823         struct inode_record *rec;
1824         struct btrfs_file_extent_item *fi;
1825         u64 num_bytes = 0;
1826         u64 disk_bytenr = 0;
1827         u64 extent_offset = 0;
1828         u64 mask = root->fs_info->sectorsize - 1;
1829         int extent_type;
1830         int ret;
1831
1832         rec = active_node->current;
1833         BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1834         rec->found_file_extent = 1;
1835
1836         if (rec->extent_start == (u64)-1) {
1837                 rec->extent_start = key->offset;
1838                 rec->extent_end = key->offset;
1839         }
1840
1841         if (rec->extent_end > key->offset)
1842                 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1843         else if (rec->extent_end < key->offset) {
1844                 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1845                                            key->offset - rec->extent_end);
1846                 if (ret < 0)
1847                         return ret;
1848         }
1849
1850         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1851         extent_type = btrfs_file_extent_type(eb, fi);
1852
1853         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1854                 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1855                 if (num_bytes == 0)
1856                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1857                 rec->found_size += num_bytes;
1858                 num_bytes = (num_bytes + mask) & ~mask;
1859         } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1860                    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1861                 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1862                 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1863                 extent_offset = btrfs_file_extent_offset(eb, fi);
1864                 if (num_bytes == 0 || (num_bytes & mask))
1865                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1866                 if (num_bytes + extent_offset >
1867                     btrfs_file_extent_ram_bytes(eb, fi))
1868                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1869                 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1870                     (btrfs_file_extent_compression(eb, fi) ||
1871                      btrfs_file_extent_encryption(eb, fi) ||
1872                      btrfs_file_extent_other_encoding(eb, fi)))
1873                         rec->errors |= I_ERR_BAD_FILE_EXTENT;
1874                 if (disk_bytenr > 0)
1875                         rec->found_size += num_bytes;
1876         } else {
1877                 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1878         }
1879         rec->extent_end = key->offset + num_bytes;
1880
1881         /*
1882          * The data reloc tree will copy full extents into its inode and then
1883          * copy the corresponding csums.  Because the extent it copied could be
1884          * a preallocated extent that hasn't been written to yet there may be no
1885          * csums to copy, ergo we won't have csums for our file extent.  This is
1886          * ok so just don't bother checking csums if the inode belongs to the
1887          * data reloc tree.
1888          */
1889         if (disk_bytenr > 0 &&
1890             btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1891                 u64 found;
1892                 if (btrfs_file_extent_compression(eb, fi))
1893                         num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1894                 else
1895                         disk_bytenr += extent_offset;
1896
1897                 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1898                 if (ret < 0)
1899                         return ret;
1900                 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1901                         if (found > 0)
1902                                 rec->found_csum_item = 1;
1903                         if (found < num_bytes)
1904                                 rec->some_csum_missing = 1;
1905                 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1906                         if (found > 0)
1907                                 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1908                 }
1909         }
1910         return 0;
1911 }
1912
1913 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1914                             struct walk_control *wc)
1915 {
1916         struct btrfs_key key;
1917         u32 nritems;
1918         int i;
1919         int ret = 0;
1920         struct cache_tree *inode_cache;
1921         struct shared_node *active_node;
1922
1923         if (wc->root_level == wc->active_node &&
1924             btrfs_root_refs(&root->root_item) == 0)
1925                 return 0;
1926
1927         active_node = wc->nodes[wc->active_node];
1928         inode_cache = &active_node->inode_cache;
1929         nritems = btrfs_header_nritems(eb);
1930         for (i = 0; i < nritems; i++) {
1931                 btrfs_item_key_to_cpu(eb, &key, i);
1932
1933                 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1934                         continue;
1935                 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1936                         continue;
1937
1938                 if (active_node->current == NULL ||
1939                     active_node->current->ino < key.objectid) {
1940                         if (active_node->current) {
1941                                 active_node->current->checked = 1;
1942                                 maybe_free_inode_rec(inode_cache,
1943                                                      active_node->current);
1944                         }
1945                         active_node->current = get_inode_rec(inode_cache,
1946                                                              key.objectid, 1);
1947                         BUG_ON(IS_ERR(active_node->current));
1948                 }
1949                 switch (key.type) {
1950                 case BTRFS_DIR_ITEM_KEY:
1951                 case BTRFS_DIR_INDEX_KEY:
1952                         ret = process_dir_item(eb, i, &key, active_node);
1953                         break;
1954                 case BTRFS_INODE_REF_KEY:
1955                         ret = process_inode_ref(eb, i, &key, active_node);
1956                         break;
1957                 case BTRFS_INODE_EXTREF_KEY:
1958                         ret = process_inode_extref(eb, i, &key, active_node);
1959                         break;
1960                 case BTRFS_INODE_ITEM_KEY:
1961                         ret = process_inode_item(eb, i, &key, active_node);
1962                         break;
1963                 case BTRFS_EXTENT_DATA_KEY:
1964                         ret = process_file_extent(root, eb, i, &key,
1965                                                   active_node);
1966                         break;
1967                 default:
1968                         break;
1969                 };
1970         }
1971         return ret;
1972 }
1973
1974 struct node_refs {
1975         u64 bytenr[BTRFS_MAX_LEVEL];
1976         u64 refs[BTRFS_MAX_LEVEL];
1977         int need_check[BTRFS_MAX_LEVEL];
1978         /* field for checking all trees */
1979         int checked[BTRFS_MAX_LEVEL];
1980         /* the corresponding extent should be marked as full backref or not */
1981         int full_backref[BTRFS_MAX_LEVEL];
1982 };
1983
1984 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
1985                              struct extent_buffer *eb, struct node_refs *nrefs,
1986                              u64 level, int check_all);
1987 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1988                             unsigned int ext_ref);
1989
1990 /*
1991  * Returns >0  Found error, not fatal, should continue
1992  * Returns <0  Fatal error, must exit the whole check
1993  * Returns 0   No errors found
1994  */
1995 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
1996                                struct node_refs *nrefs, int *level, int ext_ref)
1997 {
1998         struct extent_buffer *cur = path->nodes[0];
1999         struct btrfs_key key;
2000         u64 cur_bytenr;
2001         u32 nritems;
2002         u64 first_ino = 0;
2003         int root_level = btrfs_header_level(root->node);
2004         int i;
2005         int ret = 0; /* Final return value */
2006         int err = 0; /* Positive error bitmap */
2007
2008         cur_bytenr = cur->start;
2009
2010         /* skip to first inode item or the first inode number change */
2011         nritems = btrfs_header_nritems(cur);
2012         for (i = 0; i < nritems; i++) {
2013                 btrfs_item_key_to_cpu(cur, &key, i);
2014                 if (i == 0)
2015                         first_ino = key.objectid;
2016                 if (key.type == BTRFS_INODE_ITEM_KEY ||
2017                     (first_ino && first_ino != key.objectid))
2018                         break;
2019         }
2020         if (i == nritems) {
2021                 path->slots[0] = nritems;
2022                 return 0;
2023         }
2024         path->slots[0] = i;
2025
2026 again:
2027         err |= check_inode_item(root, path, ext_ref);
2028
2029         /* modify cur since check_inode_item may change path */
2030         cur = path->nodes[0];
2031
2032         if (err & LAST_ITEM)
2033                 goto out;
2034
2035         /* still have inode items in thie leaf */
2036         if (cur->start == cur_bytenr)
2037                 goto again;
2038
2039         /*
2040          * we have switched to another leaf, above nodes may
2041          * have changed, here walk down the path, if a node
2042          * or leaf is shared, check whether we can skip this
2043          * node or leaf.
2044          */
2045         for (i = root_level; i >= 0; i--) {
2046                 if (path->nodes[i]->start == nrefs->bytenr[i])
2047                         continue;
2048
2049                 ret = update_nodes_refs(root, path->nodes[i]->start,
2050                                 path->nodes[i], nrefs, i, 0);
2051                 if (ret)
2052                         goto out;
2053
2054                 if (!nrefs->need_check[i]) {
2055                         *level += 1;
2056                         break;
2057                 }
2058         }
2059
2060         for (i = 0; i < *level; i++) {
2061                 free_extent_buffer(path->nodes[i]);
2062                 path->nodes[i] = NULL;
2063         }
2064 out:
2065         err &= ~LAST_ITEM;
2066         if (err && !ret)
2067                 ret = err;
2068         return ret;
2069 }
2070
2071 static void reada_walk_down(struct btrfs_root *root,
2072                             struct extent_buffer *node, int slot)
2073 {
2074         struct btrfs_fs_info *fs_info = root->fs_info;
2075         u64 bytenr;
2076         u64 ptr_gen;
2077         u32 nritems;
2078         int i;
2079         int level;
2080
2081         level = btrfs_header_level(node);
2082         if (level != 1)
2083                 return;
2084
2085         nritems = btrfs_header_nritems(node);
2086         for (i = slot; i < nritems; i++) {
2087                 bytenr = btrfs_node_blockptr(node, i);
2088                 ptr_gen = btrfs_node_ptr_generation(node, i);
2089                 readahead_tree_block(fs_info, bytenr, ptr_gen);
2090         }
2091 }
2092
2093 /*
2094  * Check the child node/leaf by the following condition:
2095  * 1. the first item key of the node/leaf should be the same with the one
2096  *    in parent.
2097  * 2. block in parent node should match the child node/leaf.
2098  * 3. generation of parent node and child's header should be consistent.
2099  *
2100  * Or the child node/leaf pointed by the key in parent is not valid.
2101  *
2102  * We hope to check leaf owner too, but since subvol may share leaves,
2103  * which makes leaf owner check not so strong, key check should be
2104  * sufficient enough for that case.
2105  */
2106 static int check_child_node(struct extent_buffer *parent, int slot,
2107                             struct extent_buffer *child)
2108 {
2109         struct btrfs_key parent_key;
2110         struct btrfs_key child_key;
2111         int ret = 0;
2112
2113         btrfs_node_key_to_cpu(parent, &parent_key, slot);
2114         if (btrfs_header_level(child) == 0)
2115                 btrfs_item_key_to_cpu(child, &child_key, 0);
2116         else
2117                 btrfs_node_key_to_cpu(child, &child_key, 0);
2118
2119         if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2120                 ret = -EINVAL;
2121                 fprintf(stderr,
2122                         "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2123                         parent_key.objectid, parent_key.type, parent_key.offset,
2124                         child_key.objectid, child_key.type, child_key.offset);
2125         }
2126         if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2127                 ret = -EINVAL;
2128                 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2129                         btrfs_node_blockptr(parent, slot),
2130                         btrfs_header_bytenr(child));
2131         }
2132         if (btrfs_node_ptr_generation(parent, slot) !=
2133             btrfs_header_generation(child)) {
2134                 ret = -EINVAL;
2135                 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2136                         btrfs_header_generation(child),
2137                         btrfs_node_ptr_generation(parent, slot));
2138         }
2139         return ret;
2140 }
2141
2142 /*
2143  * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2144  * in every fs or file tree check. Here we find its all root ids, and only check
2145  * it in the fs or file tree which has the smallest root id.
2146  */
2147 static int need_check(struct btrfs_root *root, struct ulist *roots)
2148 {
2149         struct rb_node *node;
2150         struct ulist_node *u;
2151
2152         if (roots->nnodes == 1)
2153                 return 1;
2154
2155         node = rb_first(&roots->root);
2156         u = rb_entry(node, struct ulist_node, rb_node);
2157         /*
2158          * current root id is not smallest, we skip it and let it be checked
2159          * in the fs or file tree who hash the smallest root id.
2160          */
2161         if (root->objectid != u->val)
2162                 return 0;
2163
2164         return 1;
2165 }
2166
2167 static int calc_extent_flag_v2(struct btrfs_root *root, struct extent_buffer *eb,
2168                                u64 *flags_ret)
2169 {
2170         struct btrfs_root *extent_root = root->fs_info->extent_root;
2171         struct btrfs_root_item *ri = &root->root_item;
2172         struct btrfs_extent_inline_ref *iref;
2173         struct btrfs_extent_item *ei;
2174         struct btrfs_key key;
2175         struct btrfs_path *path = NULL;
2176         unsigned long ptr;
2177         unsigned long end;
2178         u64 flags;
2179         u64 owner = 0;
2180         u64 offset;
2181         int slot;
2182         int type;
2183         int ret = 0;
2184
2185         /*
2186          * Except file/reloc tree, we can not have FULL BACKREF MODE
2187          */
2188         if (root->objectid < BTRFS_FIRST_FREE_OBJECTID)
2189                 goto normal;
2190
2191         /* root node */
2192         if (eb->start == btrfs_root_bytenr(ri))
2193                 goto normal;
2194
2195         if (btrfs_header_flag(eb, BTRFS_HEADER_FLAG_RELOC))
2196                 goto full_backref;
2197
2198         owner = btrfs_header_owner(eb);
2199         if (owner == root->objectid)
2200                 goto normal;
2201
2202         path = btrfs_alloc_path();
2203         if (!path)
2204                 return -ENOMEM;
2205
2206         key.objectid = btrfs_header_bytenr(eb);
2207         key.type = (u8)-1;
2208         key.offset = (u64)-1;
2209
2210         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2211         if (ret <= 0) {
2212                 ret = -EIO;
2213                 goto out;
2214         }
2215
2216         if (ret > 0) {
2217                 ret = btrfs_previous_extent_item(extent_root, path,
2218                                                  key.objectid);
2219                 if (ret)
2220                         goto full_backref;
2221
2222         }
2223         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2224
2225         eb = path->nodes[0];
2226         slot = path->slots[0];
2227         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
2228
2229         flags = btrfs_extent_flags(eb, ei);
2230         if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
2231                 goto full_backref;
2232
2233         ptr = (unsigned long)(ei + 1);
2234         end = (unsigned long)ei + btrfs_item_size_nr(eb, slot);
2235
2236         if (key.type == BTRFS_EXTENT_ITEM_KEY)
2237                 ptr += sizeof(struct btrfs_tree_block_info);
2238
2239 next:
2240         /* Reached extent item ends normally */
2241         if (ptr == end)
2242                 goto full_backref;
2243
2244         /* Beyond extent item end, wrong item size */
2245         if (ptr > end) {
2246                 error("extent item at bytenr %llu slot %d has wrong size",
2247                         eb->start, slot);
2248                 goto full_backref;
2249         }
2250
2251         iref = (struct btrfs_extent_inline_ref *)ptr;
2252         offset = btrfs_extent_inline_ref_offset(eb, iref);
2253         type = btrfs_extent_inline_ref_type(eb, iref);
2254
2255         if (type == BTRFS_TREE_BLOCK_REF_KEY && offset == owner)
2256                 goto normal;
2257         ptr += btrfs_extent_inline_ref_size(type);
2258         goto next;
2259
2260 normal:
2261         *flags_ret &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
2262         goto out;
2263
2264 full_backref:
2265         *flags_ret |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
2266 out:
2267         btrfs_free_path(path);
2268         return ret;
2269 }
2270
2271 /*
2272  * for a tree node or leaf, we record its reference count, so later if we still
2273  * process this node or leaf, don't need to compute its reference count again.
2274  *
2275  * @bytenr  if @bytenr == (u64)-1, only update nrefs->full_backref[level]
2276  */
2277 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2278                              struct extent_buffer *eb, struct node_refs *nrefs,
2279                              u64 level, int check_all)
2280 {
2281         struct ulist *roots;
2282         u64 refs = 0;
2283         u64 flags = 0;
2284         int root_level = btrfs_header_level(root->node);
2285         int check;
2286         int ret;
2287
2288         if (nrefs->bytenr[level] == bytenr)
2289                 return 0;
2290
2291         if (bytenr != (u64)-1) {
2292                 /* the return value of this function seems a mistake */
2293                 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2294                                        level, 1, &refs, &flags);
2295                 /* temporary fix */
2296                 if (ret < 0 && !check_all)
2297                         return ret;
2298
2299                 nrefs->bytenr[level] = bytenr;
2300                 nrefs->refs[level] = refs;
2301                 nrefs->full_backref[level] = 0;
2302                 nrefs->checked[level] = 0;
2303
2304                 if (refs > 1) {
2305                         ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2306                                                    0, &roots);
2307                         if (ret)
2308                                 return -EIO;
2309
2310                         check = need_check(root, roots);
2311                         ulist_free(roots);
2312                         nrefs->need_check[level] = check;
2313                 } else {
2314                         if (!check_all) {
2315                                 nrefs->need_check[level] = 1;
2316                         } else {
2317                                 if (level == root_level) {
2318                                         nrefs->need_check[level] = 1;
2319                                 } else {
2320                                         /*
2321                                          * The node refs may have not been
2322                                          * updated if upper needs checking (the
2323                                          * lowest root_objectid) the node can
2324                                          * be checked.
2325                                          */
2326                                         nrefs->need_check[level] =
2327                                                 nrefs->need_check[level + 1];
2328                                 }
2329                         }
2330                 }
2331         }
2332
2333         if (check_all && eb) {
2334                 calc_extent_flag_v2(root, eb, &flags);
2335                 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
2336                         nrefs->full_backref[level] = 1;
2337         }
2338
2339         return 0;
2340 }
2341
2342 /*
2343  * @level           if @level == -1 means extent data item
2344  *                  else normal treeblocl.
2345  */
2346 static int should_check_extent_strictly(struct btrfs_root *root,
2347                                         struct node_refs *nrefs, int level)
2348 {
2349         int root_level = btrfs_header_level(root->node);
2350
2351         if (level > root_level || level < -1)
2352                 return 1;
2353         if (level == root_level)
2354                 return 1;
2355         /*
2356          * if the upper node is marked full backref, it should contain shared
2357          * backref of the parent (except owner == root->objectid).
2358          */
2359         while (++level <= root_level)
2360                 if (nrefs->refs[level] > 1)
2361                         return 0;
2362
2363         return 1;
2364 }
2365
2366 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2367                           struct walk_control *wc, int *level,
2368                           struct node_refs *nrefs)
2369 {
2370         enum btrfs_tree_block_status status;
2371         u64 bytenr;
2372         u64 ptr_gen;
2373         struct btrfs_fs_info *fs_info = root->fs_info;
2374         struct extent_buffer *next;
2375         struct extent_buffer *cur;
2376         int ret, err = 0;
2377         u64 refs;
2378
2379         WARN_ON(*level < 0);
2380         WARN_ON(*level >= BTRFS_MAX_LEVEL);
2381
2382         if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2383                 refs = nrefs->refs[*level];
2384                 ret = 0;
2385         } else {
2386                 ret = btrfs_lookup_extent_info(NULL, root,
2387                                        path->nodes[*level]->start,
2388                                        *level, 1, &refs, NULL);
2389                 if (ret < 0) {
2390                         err = ret;
2391                         goto out;
2392                 }
2393                 nrefs->bytenr[*level] = path->nodes[*level]->start;
2394                 nrefs->refs[*level] = refs;
2395         }
2396
2397         if (refs > 1) {
2398                 ret = enter_shared_node(root, path->nodes[*level]->start,
2399                                         refs, wc, *level);
2400                 if (ret > 0) {
2401                         err = ret;
2402                         goto out;
2403                 }
2404         }
2405
2406         while (*level >= 0) {
2407                 WARN_ON(*level < 0);
2408                 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2409                 cur = path->nodes[*level];
2410
2411                 if (btrfs_header_level(cur) != *level)
2412                         WARN_ON(1);
2413
2414                 if (path->slots[*level] >= btrfs_header_nritems(cur))
2415                         break;
2416                 if (*level == 0) {
2417                         ret = process_one_leaf(root, cur, wc);
2418                         if (ret < 0)
2419                                 err = ret;
2420                         break;
2421                 }
2422                 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2423                 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2424
2425                 if (bytenr == nrefs->bytenr[*level - 1]) {
2426                         refs = nrefs->refs[*level - 1];
2427                 } else {
2428                         ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2429                                         *level - 1, 1, &refs, NULL);
2430                         if (ret < 0) {
2431                                 refs = 0;
2432                         } else {
2433                                 nrefs->bytenr[*level - 1] = bytenr;
2434                                 nrefs->refs[*level - 1] = refs;
2435                         }
2436                 }
2437
2438                 if (refs > 1) {
2439                         ret = enter_shared_node(root, bytenr, refs,
2440                                                 wc, *level - 1);
2441                         if (ret > 0) {
2442                                 path->slots[*level]++;
2443                                 continue;
2444                         }
2445                 }
2446
2447                 next = btrfs_find_tree_block(fs_info, bytenr, fs_info->nodesize);
2448                 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2449                         free_extent_buffer(next);
2450                         reada_walk_down(root, cur, path->slots[*level]);
2451                         next = read_tree_block(root->fs_info, bytenr, ptr_gen);
2452                         if (!extent_buffer_uptodate(next)) {
2453                                 struct btrfs_key node_key;
2454
2455                                 btrfs_node_key_to_cpu(path->nodes[*level],
2456                                                       &node_key,
2457                                                       path->slots[*level]);
2458                                 btrfs_add_corrupt_extent_record(root->fs_info,
2459                                                 &node_key,
2460                                                 path->nodes[*level]->start,
2461                                                 root->fs_info->nodesize,
2462                                                 *level);
2463                                 err = -EIO;
2464                                 goto out;
2465                         }
2466                 }
2467
2468                 ret = check_child_node(cur, path->slots[*level], next);
2469                 if (ret) {
2470                         free_extent_buffer(next);
2471                         err = ret;
2472                         goto out;
2473                 }
2474
2475                 if (btrfs_is_leaf(next))
2476                         status = btrfs_check_leaf(root, NULL, next);
2477                 else
2478                         status = btrfs_check_node(root, NULL, next);
2479                 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2480                         free_extent_buffer(next);
2481                         err = -EIO;
2482                         goto out;
2483                 }
2484
2485                 *level = *level - 1;
2486                 free_extent_buffer(path->nodes[*level]);
2487                 path->nodes[*level] = next;
2488                 path->slots[*level] = 0;
2489         }
2490 out:
2491         path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2492         return err;
2493 }
2494
2495 static int fs_root_objectid(u64 objectid);
2496
2497 /*
2498  * Update global fs information.
2499  */
2500 static void account_bytes(struct btrfs_root *root, struct btrfs_path *path,
2501                          int level)
2502 {
2503         u32 free_nrs;
2504         struct extent_buffer *eb = path->nodes[level];
2505
2506         total_btree_bytes += eb->len;
2507         if (fs_root_objectid(root->objectid))
2508                 total_fs_tree_bytes += eb->len;
2509         if (btrfs_header_owner(eb) == BTRFS_EXTENT_TREE_OBJECTID)
2510                 total_extent_tree_bytes += eb->len;
2511
2512         if (level == 0) {
2513                 btree_space_waste += btrfs_leaf_free_space(root, eb);
2514         } else {
2515                 free_nrs = (BTRFS_NODEPTRS_PER_BLOCK(root) -
2516                             btrfs_header_nritems(eb));
2517                 btree_space_waste += free_nrs * sizeof(struct btrfs_key_ptr);
2518         }
2519 }
2520
2521 /*
2522  * This function only handles BACKREF_MISSING,
2523  * If corresponding extent item exists, increase the ref, else insert an extent
2524  * item and backref.
2525  *
2526  * Returns error bits after repair.
2527  */
2528 static int repair_tree_block_ref(struct btrfs_trans_handle *trans,
2529                                  struct btrfs_root *root,
2530                                  struct extent_buffer *node,
2531                                  struct node_refs *nrefs, int level, int err)
2532 {
2533         struct btrfs_fs_info *fs_info = root->fs_info;
2534         struct btrfs_root *extent_root = fs_info->extent_root;
2535         struct btrfs_path path;
2536         struct btrfs_extent_item *ei;
2537         struct btrfs_tree_block_info *bi;
2538         struct btrfs_key key;
2539         struct extent_buffer *eb;
2540         u32 size = sizeof(*ei);
2541         u32 node_size = root->fs_info->nodesize;
2542         int insert_extent = 0;
2543         int skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);
2544         int root_level = btrfs_header_level(root->node);
2545         int generation;
2546         int ret;
2547         u64 owner;
2548         u64 bytenr;
2549         u64 flags = BTRFS_EXTENT_FLAG_TREE_BLOCK;
2550         u64 parent = 0;
2551
2552         if ((err & BACKREF_MISSING) == 0)
2553                 return err;
2554
2555         WARN_ON(level > BTRFS_MAX_LEVEL);
2556         WARN_ON(level < 0);
2557
2558         btrfs_init_path(&path);
2559         bytenr = btrfs_header_bytenr(node);
2560         owner = btrfs_header_owner(node);
2561         generation = btrfs_header_generation(node);
2562
2563         key.objectid = bytenr;
2564         key.type = (u8)-1;
2565         key.offset = (u64)-1;
2566
2567         /* Search for the extent item */
2568         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2569         if (ret <= 0) {
2570                 ret = -EIO;
2571                 goto out;
2572         }
2573
2574         ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
2575         if (ret)
2576                 insert_extent = 1;
2577
2578         /* calculate if the extent item flag is full backref or not */
2579         if (nrefs->full_backref[level] != 0)
2580                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
2581
2582         /* insert an extent item */
2583         if (insert_extent) {
2584                 struct btrfs_disk_key copy_key;
2585
2586                 generation = btrfs_header_generation(node);
2587
2588                 if (level < root_level && nrefs->full_backref[level + 1] &&
2589                     owner != root->objectid) {
2590                         flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
2591                 }
2592
2593                 key.objectid = bytenr;
2594                 if (!skinny_metadata) {
2595                         key.type = BTRFS_EXTENT_ITEM_KEY;
2596                         key.offset = node_size;
2597                         size += sizeof(*bi);
2598                 } else {
2599                         key.type = BTRFS_METADATA_ITEM_KEY;
2600                         key.offset = level;
2601                 }
2602
2603                 btrfs_release_path(&path);
2604                 ret = btrfs_insert_empty_item(trans, extent_root, &path, &key,
2605                                               size);
2606                 if (ret)
2607                         goto out;
2608
2609                 eb = path.nodes[0];
2610                 ei = btrfs_item_ptr(eb, path.slots[0], struct btrfs_extent_item);
2611
2612                 btrfs_set_extent_refs(eb, ei, 0);
2613                 btrfs_set_extent_generation(eb, ei, generation);
2614                 btrfs_set_extent_flags(eb, ei, flags);
2615
2616                 if (!skinny_metadata) {
2617                         bi = (struct btrfs_tree_block_info *)(ei + 1);
2618                         memset_extent_buffer(eb, 0, (unsigned long)bi,
2619                                              sizeof(*bi));
2620                         btrfs_set_disk_key_objectid(&copy_key, root->objectid);
2621                         btrfs_set_disk_key_type(&copy_key, 0);
2622                         btrfs_set_disk_key_offset(&copy_key, 0);
2623
2624                         btrfs_set_tree_block_level(eb, bi, level);
2625                         btrfs_set_tree_block_key(eb, bi, &copy_key);
2626                 }
2627                 btrfs_mark_buffer_dirty(eb);
2628                 printf("Added an extent item [%llu %u]\n", bytenr, node_size);
2629                 btrfs_update_block_group(trans, extent_root, bytenr, node_size,
2630                                          1, 0);
2631
2632                 nrefs->refs[level] = 0;
2633                 nrefs->full_backref[level] =
2634                         flags & BTRFS_BLOCK_FLAG_FULL_BACKREF;
2635                 btrfs_release_path(&path);
2636         }
2637
2638         if (level < root_level && nrefs->full_backref[level + 1] &&
2639             owner != root->objectid)
2640                 parent = nrefs->bytenr[level + 1];
2641
2642         /* increase the ref */
2643         ret = btrfs_inc_extent_ref(trans, extent_root, bytenr, node_size,
2644                         parent, root->objectid, level, 0);
2645
2646         nrefs->refs[level]++;
2647 out:
2648         btrfs_release_path(&path);
2649         if (ret) {
2650                 error(
2651         "failed to repair tree block ref start %llu root %llu due to %s",
2652                       bytenr, root->objectid, strerror(-ret));
2653         } else {
2654                 printf("Added one tree block ref start %llu %s %llu\n",
2655                        bytenr, parent ? "parent" : "root",
2656                        parent ? parent : root->objectid);
2657                 err &= ~BACKREF_MISSING;
2658         }
2659
2660         return err;
2661 }
2662
2663 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2664                             unsigned int ext_ref);
2665 static int check_tree_block_ref(struct btrfs_root *root,
2666                                 struct extent_buffer *eb, u64 bytenr,
2667                                 int level, u64 owner, struct node_refs *nrefs);
2668 static int check_leaf_items(struct btrfs_trans_handle *trans,
2669                             struct btrfs_root *root, struct btrfs_path *path,
2670                             struct node_refs *nrefs, int account_bytes);
2671
2672 /*
2673  * @trans      just for lowmem repair mode
2674  * @check all  if not 0 then check all tree block backrefs and items
2675  *             0 then just check relationship of items in fs tree(s)
2676  *
2677  * Returns >0  Found error, should continue
2678  * Returns <0  Fatal error, must exit the whole check
2679  * Returns 0   No errors found
2680  */
2681 static int walk_down_tree_v2(struct btrfs_trans_handle *trans,
2682                              struct btrfs_root *root, struct btrfs_path *path,
2683                              int *level, struct node_refs *nrefs, int ext_ref,
2684                              int check_all)
2685
2686 {
2687         enum btrfs_tree_block_status status;
2688         u64 bytenr;
2689         u64 ptr_gen;
2690         struct btrfs_fs_info *fs_info = root->fs_info;
2691         struct extent_buffer *next;
2692         struct extent_buffer *cur;
2693         int ret;
2694         int err = 0;
2695         int check;
2696         int account_file_data = 0;
2697
2698         WARN_ON(*level < 0);
2699         WARN_ON(*level >= BTRFS_MAX_LEVEL);
2700
2701         ret = update_nodes_refs(root, btrfs_header_bytenr(path->nodes[*level]),
2702                                 path->nodes[*level], nrefs, *level, check_all);
2703         if (ret < 0)
2704                 return ret;
2705
2706         while (*level >= 0) {
2707                 WARN_ON(*level < 0);
2708                 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2709                 cur = path->nodes[*level];
2710                 bytenr = btrfs_header_bytenr(cur);
2711                 check = nrefs->need_check[*level];
2712
2713                 if (btrfs_header_level(cur) != *level)
2714                         WARN_ON(1);
2715                /*
2716                 * Update bytes accounting and check tree block ref
2717                 * NOTE: Doing accounting and check before checking nritems
2718                 * is necessary because of empty node/leaf.
2719                 */
2720                 if ((check_all && !nrefs->checked[*level]) ||
2721                     (!check_all && nrefs->need_check[*level])) {
2722                         ret = check_tree_block_ref(root, cur,
2723                            btrfs_header_bytenr(cur), btrfs_header_level(cur),
2724                            btrfs_header_owner(cur), nrefs);
2725
2726                         if (repair && ret)
2727                                 ret = repair_tree_block_ref(trans, root,
2728                                     path->nodes[*level], nrefs, *level, ret);
2729                         err |= ret;
2730
2731                         if (check_all && nrefs->need_check[*level] &&
2732                                 nrefs->refs[*level]) {
2733                                 account_bytes(root, path, *level);
2734                                 account_file_data = 1;
2735                         }
2736                         nrefs->checked[*level] = 1;
2737                 }
2738
2739                 if (path->slots[*level] >= btrfs_header_nritems(cur))
2740                         break;
2741
2742                 /* Don't forgot to check leaf/node validation */
2743                 if (*level == 0) {
2744                         /* skip duplicate check */
2745                         if (check || !check_all) {
2746                                 ret = btrfs_check_leaf(root, NULL, cur);
2747                                 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2748                                         err |= -EIO;
2749                                         break;
2750                                 }
2751                         }
2752
2753                         ret = 0;
2754                         if (!check_all)
2755                                 ret = process_one_leaf_v2(root, path, nrefs,
2756                                                           level, ext_ref);
2757                         else
2758                                 ret = check_leaf_items(trans, root, path,
2759                                                nrefs, account_file_data);
2760                         err |= ret;
2761                         break;
2762                 } else {
2763                         if (check || !check_all) {
2764                                 ret = btrfs_check_node(root, NULL, cur);
2765                                 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2766                                         err |= -EIO;
2767                                         break;
2768                                 }
2769                         }
2770                 }
2771
2772                 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2773                 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2774
2775                 ret = update_nodes_refs(root, bytenr, NULL, nrefs, *level - 1,
2776                                         check_all);
2777                 if (ret < 0)
2778                         break;
2779                 /*
2780                  * check all trees in check_chunks_and_extent_v2
2781                  * check shared node once in check_fs_roots
2782                  */
2783                 if (!check_all && !nrefs->need_check[*level - 1]) {
2784                         path->slots[*level]++;
2785                         continue;
2786                 }
2787
2788                 next = btrfs_find_tree_block(fs_info, bytenr, fs_info->nodesize);
2789                 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2790                         free_extent_buffer(next);
2791                         reada_walk_down(root, cur, path->slots[*level]);
2792                         next = read_tree_block(fs_info, bytenr, ptr_gen);
2793                         if (!extent_buffer_uptodate(next)) {
2794                                 struct btrfs_key node_key;
2795
2796                                 btrfs_node_key_to_cpu(path->nodes[*level],
2797                                                       &node_key,
2798                                                       path->slots[*level]);
2799                                 btrfs_add_corrupt_extent_record(fs_info,
2800                                         &node_key, path->nodes[*level]->start,
2801                                         fs_info->nodesize, *level);
2802                                 err |= -EIO;
2803                                 break;
2804                         }
2805                 }
2806
2807                 ret = check_child_node(cur, path->slots[*level], next);
2808                 err |= ret;
2809                 if (ret < 0)
2810                         break;
2811
2812                 if (btrfs_is_leaf(next))
2813                         status = btrfs_check_leaf(root, NULL, next);
2814                 else
2815                         status = btrfs_check_node(root, NULL, next);
2816                 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2817                         free_extent_buffer(next);
2818                         err |= -EIO;
2819                         break;
2820                 }
2821
2822                 *level = *level - 1;
2823                 free_extent_buffer(path->nodes[*level]);
2824                 path->nodes[*level] = next;
2825                 path->slots[*level] = 0;
2826                 account_file_data = 0;
2827
2828                 update_nodes_refs(root, (u64)-1, next, nrefs, *level, check_all);
2829         }
2830         return err;
2831 }
2832
2833 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2834                         struct walk_control *wc, int *level)
2835 {
2836         int i;
2837         struct extent_buffer *leaf;
2838
2839         for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2840                 leaf = path->nodes[i];
2841                 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2842                         path->slots[i]++;
2843                         *level = i;
2844                         return 0;
2845                 } else {
2846                         free_extent_buffer(path->nodes[*level]);
2847                         path->nodes[*level] = NULL;
2848                         BUG_ON(*level > wc->active_node);
2849                         if (*level == wc->active_node)
2850                                 leave_shared_node(root, wc, *level);
2851                         *level = i + 1;
2852                 }
2853         }
2854         return 1;
2855 }
2856
2857 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2858                            int *level)
2859 {
2860         int i;
2861         struct extent_buffer *leaf;
2862
2863         for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2864                 leaf = path->nodes[i];
2865                 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2866                         path->slots[i]++;
2867                         *level = i;
2868                         return 0;
2869                 } else {
2870                         free_extent_buffer(path->nodes[*level]);
2871                         path->nodes[*level] = NULL;
2872                         *level = i + 1;
2873                 }
2874         }
2875         return 1;
2876 }
2877
2878 static int check_root_dir(struct inode_record *rec)
2879 {
2880         struct inode_backref *backref;
2881         int ret = -1;
2882
2883         if (!rec->found_inode_item || rec->errors)
2884                 goto out;
2885         if (rec->nlink != 1 || rec->found_link != 0)
2886                 goto out;
2887         if (list_empty(&rec->backrefs))
2888                 goto out;
2889         backref = to_inode_backref(rec->backrefs.next);
2890         if (!backref->found_inode_ref)
2891                 goto out;
2892         if (backref->index != 0 || backref->namelen != 2 ||
2893             memcmp(backref->name, "..", 2))
2894                 goto out;
2895         if (backref->found_dir_index || backref->found_dir_item)
2896                 goto out;
2897         ret = 0;
2898 out:
2899         return ret;
2900 }
2901
2902 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2903                               struct btrfs_root *root, struct btrfs_path *path,
2904                               struct inode_record *rec)
2905 {
2906         struct btrfs_inode_item *ei;
2907         struct btrfs_key key;
2908         int ret;
2909
2910         key.objectid = rec->ino;
2911         key.type = BTRFS_INODE_ITEM_KEY;
2912         key.offset = (u64)-1;
2913
2914         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2915         if (ret < 0)
2916                 goto out;
2917         if (ret) {
2918                 if (!path->slots[0]) {
2919                         ret = -ENOENT;
2920                         goto out;
2921                 }
2922                 path->slots[0]--;
2923                 ret = 0;
2924         }
2925         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2926         if (key.objectid != rec->ino) {
2927                 ret = -ENOENT;
2928                 goto out;
2929         }
2930
2931         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2932                             struct btrfs_inode_item);
2933         btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2934         btrfs_mark_buffer_dirty(path->nodes[0]);
2935         rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2936         printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2937                root->root_key.objectid);
2938 out:
2939         btrfs_release_path(path);
2940         return ret;
2941 }
2942
2943 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2944                                     struct btrfs_root *root,
2945                                     struct btrfs_path *path,
2946                                     struct inode_record *rec)
2947 {
2948         int ret;
2949
2950         ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2951         btrfs_release_path(path);
2952         if (!ret)
2953                 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2954         return ret;
2955 }
2956
2957 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2958                                struct btrfs_root *root,
2959                                struct btrfs_path *path,
2960                                struct inode_record *rec)
2961 {
2962         struct btrfs_inode_item *ei;
2963         struct btrfs_key key;
2964         int ret = 0;
2965
2966         key.objectid = rec->ino;
2967         key.type = BTRFS_INODE_ITEM_KEY;
2968         key.offset = 0;
2969
2970         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2971         if (ret) {
2972                 if (ret > 0)
2973                         ret = -ENOENT;
2974                 goto out;
2975         }
2976
2977         /* Since ret == 0, no need to check anything */
2978         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2979                             struct btrfs_inode_item);
2980         btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2981         btrfs_mark_buffer_dirty(path->nodes[0]);
2982         rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2983         printf("reset nbytes for ino %llu root %llu\n",
2984                rec->ino, root->root_key.objectid);
2985 out:
2986         btrfs_release_path(path);
2987         return ret;
2988 }
2989
2990 static int add_missing_dir_index(struct btrfs_root *root,
2991                                  struct cache_tree *inode_cache,
2992                                  struct inode_record *rec,
2993                                  struct inode_backref *backref)
2994 {
2995         struct btrfs_path path;
2996         struct btrfs_trans_handle *trans;
2997         struct btrfs_dir_item *dir_item;
2998         struct extent_buffer *leaf;
2999         struct btrfs_key key;
3000         struct btrfs_disk_key disk_key;
3001         struct inode_record *dir_rec;
3002         unsigned long name_ptr;
3003         u32 data_size = sizeof(*dir_item) + backref->namelen;
3004         int ret;
3005
3006         trans = btrfs_start_transaction(root, 1);
3007         if (IS_ERR(trans))
3008                 return PTR_ERR(trans);
3009
3010         fprintf(stderr, "repairing missing dir index item for inode %llu\n",
3011                 (unsigned long long)rec->ino);
3012
3013         btrfs_init_path(&path);
3014         key.objectid = backref->dir;
3015         key.type = BTRFS_DIR_INDEX_KEY;
3016         key.offset = backref->index;
3017         ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
3018         BUG_ON(ret);
3019
3020         leaf = path.nodes[0];
3021         dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
3022
3023         disk_key.objectid = cpu_to_le64(rec->ino);
3024         disk_key.type = BTRFS_INODE_ITEM_KEY;
3025         disk_key.offset = 0;
3026
3027         btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
3028         btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
3029         btrfs_set_dir_data_len(leaf, dir_item, 0);
3030         btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
3031         name_ptr = (unsigned long)(dir_item + 1);
3032         write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
3033         btrfs_mark_buffer_dirty(leaf);
3034         btrfs_release_path(&path);
3035         btrfs_commit_transaction(trans, root);
3036
3037         backref->found_dir_index = 1;
3038         dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
3039         BUG_ON(IS_ERR(dir_rec));
3040         if (!dir_rec)
3041                 return 0;
3042         dir_rec->found_size += backref->namelen;
3043         if (dir_rec->found_size == dir_rec->isize &&
3044             (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
3045                 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
3046         if (dir_rec->found_size != dir_rec->isize)
3047                 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
3048
3049         return 0;
3050 }
3051
3052 static int delete_dir_index(struct btrfs_root *root,
3053                             struct inode_backref *backref)
3054 {
3055         struct btrfs_trans_handle *trans;
3056         struct btrfs_dir_item *di;
3057         struct btrfs_path path;
3058         int ret = 0;
3059
3060         trans = btrfs_start_transaction(root, 1);
3061         if (IS_ERR(trans))
3062                 return PTR_ERR(trans);
3063
3064         fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
3065                 (unsigned long long)backref->dir,
3066                 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
3067                 (unsigned long long)root->objectid);
3068
3069         btrfs_init_path(&path);
3070         di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
3071                                     backref->name, backref->namelen,
3072                                     backref->index, -1);
3073         if (IS_ERR(di)) {
3074                 ret = PTR_ERR(di);
3075                 btrfs_release_path(&path);
3076                 btrfs_commit_transaction(trans, root);
3077                 if (ret == -ENOENT)
3078                         return 0;
3079                 return ret;
3080         }
3081
3082         if (!di)
3083                 ret = btrfs_del_item(trans, root, &path);
3084         else
3085                 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
3086         BUG_ON(ret);
3087         btrfs_release_path(&path);
3088         btrfs_commit_transaction(trans, root);
3089         return ret;
3090 }
3091
3092 static int __create_inode_item(struct btrfs_trans_handle *trans,
3093                                struct btrfs_root *root, u64 ino, u64 size,
3094                                u64 nbytes, u64 nlink, u32 mode)
3095 {
3096         struct btrfs_inode_item ii;
3097         time_t now = time(NULL);
3098         int ret;
3099
3100         btrfs_set_stack_inode_size(&ii, size);
3101         btrfs_set_stack_inode_nbytes(&ii, nbytes);
3102         btrfs_set_stack_inode_nlink(&ii, nlink);
3103         btrfs_set_stack_inode_mode(&ii, mode);
3104         btrfs_set_stack_inode_generation(&ii, trans->transid);
3105         btrfs_set_stack_timespec_nsec(&ii.atime, 0);
3106         btrfs_set_stack_timespec_sec(&ii.ctime, now);
3107         btrfs_set_stack_timespec_nsec(&ii.ctime, 0);
3108         btrfs_set_stack_timespec_sec(&ii.mtime, now);
3109         btrfs_set_stack_timespec_nsec(&ii.mtime, 0);
3110         btrfs_set_stack_timespec_sec(&ii.otime, 0);
3111         btrfs_set_stack_timespec_nsec(&ii.otime, 0);
3112
3113         ret = btrfs_insert_inode(trans, root, ino, &ii);
3114         ASSERT(!ret);
3115
3116         warning("root %llu inode %llu recreating inode item, this may "
3117                 "be incomplete, please check permissions and content after "
3118                 "the fsck completes.\n", (unsigned long long)root->objectid,
3119                 (unsigned long long)ino);
3120
3121         return 0;
3122 }
3123
3124 static int create_inode_item_lowmem(struct btrfs_trans_handle *trans,
3125                                     struct btrfs_root *root, u64 ino,
3126                                     u8 filetype)
3127 {
3128         u32 mode = (filetype == BTRFS_FT_DIR ? S_IFDIR : S_IFREG) | 0755;
3129
3130         return __create_inode_item(trans, root, ino, 0, 0, 0, mode);
3131 }
3132
3133 static int create_inode_item(struct btrfs_root *root,
3134                              struct inode_record *rec, int root_dir)
3135 {
3136         struct btrfs_trans_handle *trans;
3137         u64 nlink = 0;
3138         u32 mode = 0;
3139         u64 size = 0;
3140         int ret;
3141
3142         trans = btrfs_start_transaction(root, 1);
3143         if (IS_ERR(trans)) {
3144                 ret = PTR_ERR(trans);
3145                 return ret;
3146         }
3147
3148         nlink = root_dir ? 1 : rec->found_link;
3149         if (rec->found_dir_item) {
3150                 if (rec->found_file_extent)
3151                         fprintf(stderr, "root %llu inode %llu has both a dir "
3152                                 "item and extents, unsure if it is a dir or a "
3153                                 "regular file so setting it as a directory\n",
3154                                 (unsigned long long)root->objectid,
3155                                 (unsigned long long)rec->ino);
3156                 mode = S_IFDIR | 0755;
3157                 size = rec->found_size;
3158         } else if (!rec->found_dir_item) {
3159                 size = rec->extent_end;
3160                 mode =  S_IFREG | 0755;
3161         }
3162
3163         ret = __create_inode_item(trans, root, rec->ino, size, rec->nbytes,
3164                                   nlink, mode);
3165         btrfs_commit_transaction(trans, root);
3166         return 0;
3167 }
3168
3169 static int repair_inode_backrefs(struct btrfs_root *root,
3170                                  struct inode_record *rec,
3171                                  struct cache_tree *inode_cache,
3172                                  int delete)
3173 {
3174         struct inode_backref *tmp, *backref;
3175         u64 root_dirid = btrfs_root_dirid(&root->root_item);
3176         int ret = 0;
3177         int repaired = 0;
3178
3179         list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
3180                 if (!delete && rec->ino == root_dirid) {
3181                         if (!rec->found_inode_item) {
3182                                 ret = create_inode_item(root, rec, 1);
3183                                 if (ret)
3184                                         break;
3185                                 repaired++;
3186                         }
3187                 }
3188
3189                 /* Index 0 for root dir's are special, don't mess with it */
3190                 if (rec->ino == root_dirid && backref->index == 0)
3191                         continue;
3192
3193                 if (delete &&
3194                     ((backref->found_dir_index && !backref->found_inode_ref) ||
3195                      (backref->found_dir_index && backref->found_inode_ref &&
3196                       (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
3197                         ret = delete_dir_index(root, backref);
3198                         if (ret)
3199                                 break;
3200                         repaired++;
3201                         list_del(&backref->list);
3202                         free(backref);
3203                         continue;
3204                 }
3205
3206                 if (!delete && !backref->found_dir_index &&
3207                     backref->found_dir_item && backref->found_inode_ref) {
3208                         ret = add_missing_dir_index(root, inode_cache, rec,
3209                                                     backref);
3210                         if (ret)
3211                                 break;
3212                         repaired++;
3213                         if (backref->found_dir_item &&
3214                             backref->found_dir_index) {
3215                                 if (!backref->errors &&
3216                                     backref->found_inode_ref) {
3217                                         list_del(&backref->list);
3218                                         free(backref);
3219                                         continue;
3220                                 }
3221                         }
3222                 }
3223
3224                 if (!delete && (!backref->found_dir_index &&
3225                                 !backref->found_dir_item &&
3226                                 backref->found_inode_ref)) {
3227                         struct btrfs_trans_handle *trans;
3228                         struct btrfs_key location;
3229
3230                         ret = check_dir_conflict(root, backref->name,
3231                                                  backref->namelen,
3232                                                  backref->dir,
3233                                                  backref->index);
3234                         if (ret) {
3235                                 /*
3236                                  * let nlink fixing routine to handle it,
3237                                  * which can do it better.
3238                                  */
3239                                 ret = 0;
3240                                 break;
3241                         }
3242                         location.objectid = rec->ino;
3243                         location.type = BTRFS_INODE_ITEM_KEY;
3244                         location.offset = 0;
3245
3246                         trans = btrfs_start_transaction(root, 1);
3247                         if (IS_ERR(trans)) {
3248                                 ret = PTR_ERR(trans);
3249                                 break;
3250                         }
3251                         fprintf(stderr, "adding missing dir index/item pair "
3252                                 "for inode %llu\n",
3253                                 (unsigned long long)rec->ino);
3254                         ret = btrfs_insert_dir_item(trans, root, backref->name,
3255                                                     backref->namelen,
3256                                                     backref->dir, &location,
3257                                                     imode_to_type(rec->imode),
3258                                                     backref->index);
3259                         BUG_ON(ret);
3260                         btrfs_commit_transaction(trans, root);
3261                         repaired++;
3262                 }
3263
3264                 if (!delete && (backref->found_inode_ref &&
3265                                 backref->found_dir_index &&
3266                                 backref->found_dir_item &&
3267                                 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
3268                                 !rec->found_inode_item)) {
3269                         ret = create_inode_item(root, rec, 0);
3270                         if (ret)
3271                                 break;
3272                         repaired++;
3273                 }
3274
3275         }
3276         return ret ? ret : repaired;
3277 }
3278
3279 /*
3280  * To determine the file type for nlink/inode_item repair
3281  *
3282  * Return 0 if file type is found and BTRFS_FT_* is stored into type.
3283  * Return -ENOENT if file type is not found.
3284  */
3285 static int find_file_type(struct inode_record *rec, u8 *type)
3286 {
3287         struct inode_backref *backref;
3288
3289         /* For inode item recovered case */
3290         if (rec->found_inode_item) {
3291                 *type = imode_to_type(rec->imode);
3292                 return 0;
3293         }
3294
3295         list_for_each_entry(backref, &rec->backrefs, list) {
3296                 if (backref->found_dir_index || backref->found_dir_item) {
3297                         *type = backref->filetype;
3298                         return 0;
3299                 }
3300         }
3301         return -ENOENT;
3302 }
3303
3304 /*
3305  * To determine the file name for nlink repair
3306  *
3307  * Return 0 if file name is found, set name and namelen.
3308  * Return -ENOENT if file name is not found.
3309  */
3310 static int find_file_name(struct inode_record *rec,
3311                           char *name, int *namelen)
3312 {
3313         struct inode_backref *backref;
3314
3315         list_for_each_entry(backref, &rec->backrefs, list) {
3316                 if (backref->found_dir_index || backref->found_dir_item ||
3317                     backref->found_inode_ref) {
3318                         memcpy(name, backref->name, backref->namelen);
3319                         *namelen = backref->namelen;
3320                         return 0;
3321                 }
3322         }
3323         return -ENOENT;
3324 }
3325
3326 /* Reset the nlink of the inode to the correct one */
3327 static int reset_nlink(struct btrfs_trans_handle *trans,
3328                        struct btrfs_root *root,
3329                        struct btrfs_path *path,
3330                        struct inode_record *rec)
3331 {
3332         struct inode_backref *backref;
3333         struct inode_backref *tmp;
3334         struct btrfs_key key;
3335         struct btrfs_inode_item *inode_item;
3336         int ret = 0;
3337
3338         /* We don't believe this either, reset it and iterate backref */
3339         rec->found_link = 0;
3340
3341         /* Remove all backref including the valid ones */
3342         list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
3343                 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
3344                                    backref->index, backref->name,
3345                                    backref->namelen, 0);
3346                 if (ret < 0)
3347                         goto out;
3348
3349                 /* remove invalid backref, so it won't be added back */
3350                 if (!(backref->found_dir_index &&
3351                       backref->found_dir_item &&
3352                       backref->found_inode_ref)) {
3353                         list_del(&backref->list);
3354                         free(backref);
3355                 } else {
3356                         rec->found_link++;
3357                 }
3358         }
3359
3360         /* Set nlink to 0 */
3361         key.objectid = rec->ino;
3362         key.type = BTRFS_INODE_ITEM_KEY;
3363         key.offset = 0;
3364         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
3365         if (ret < 0)
3366                 goto out;
3367         if (ret > 0) {
3368                 ret = -ENOENT;
3369                 goto out;
3370         }
3371         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
3372                                     struct btrfs_inode_item);
3373         btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
3374         btrfs_mark_buffer_dirty(path->nodes[0]);
3375         btrfs_release_path(path);
3376
3377         /*
3378          * Add back valid inode_ref/dir_item/dir_index,
3379          * add_link() will handle the nlink inc, so new nlink must be correct
3380          */
3381         list_for_each_entry(backref, &rec->backrefs, list) {
3382                 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
3383                                      backref->name, backref->namelen,
3384                                      backref->filetype, &backref->index, 1, 0);
3385                 if (ret < 0)
3386                         goto out;
3387         }
3388 out:
3389         btrfs_release_path(path);
3390         return ret;
3391 }
3392
3393 static int get_highest_inode(struct btrfs_trans_handle *trans,
3394                                 struct btrfs_root *root,
3395                                 struct btrfs_path *path,
3396                                 u64 *highest_ino)
3397 {
3398         struct btrfs_key key, found_key;
3399         int ret;
3400
3401         btrfs_init_path(path);
3402         key.objectid = BTRFS_LAST_FREE_OBJECTID;
3403         key.offset = -1;
3404         key.type = BTRFS_INODE_ITEM_KEY;
3405         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3406         if (ret == 1) {
3407                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
3408                                 path->slots[0] - 1);
3409                 *highest_ino = found_key.objectid;
3410                 ret = 0;
3411         }
3412         if (*highest_ino >= BTRFS_LAST_FREE_OBJECTID)
3413                 ret = -EOVERFLOW;
3414         btrfs_release_path(path);
3415         return ret;
3416 }
3417
3418 /*
3419  * Link inode to dir 'lost+found'. Increase @ref_count.
3420  *
3421  * Returns 0 means success.
3422  * Returns <0 means failure.
3423  */
3424 static int link_inode_to_lostfound(struct btrfs_trans_handle *trans,
3425                                    struct btrfs_root *root,
3426                                    struct btrfs_path *path,
3427                                    u64 ino, char *namebuf, u32 name_len,
3428                                    u8 filetype, u64 *ref_count)
3429 {
3430         char *dir_name = "lost+found";
3431         u64 lost_found_ino;
3432         int ret;
3433         u32 mode = 0700;
3434
3435         btrfs_release_path(path);
3436         ret = get_highest_inode(trans, root, path, &lost_found_ino);
3437         if (ret < 0)
3438                 goto out;
3439         lost_found_ino++;
3440
3441         ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
3442                           BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
3443                           mode);
3444         if (ret < 0) {
3445                 error("failed to create '%s' dir: %s", dir_name, strerror(-ret));
3446                 goto out;
3447         }
3448         ret = btrfs_add_link(trans, root, ino, lost_found_ino,
3449                              namebuf, name_len, filetype, NULL, 1, 0);
3450         /*
3451          * Add ".INO" suffix several times to handle case where
3452          * "FILENAME.INO" is already taken by another file.
3453          */
3454         while (ret == -EEXIST) {
3455                 /*
3456                  * Conflicting file name, add ".INO" as suffix * +1 for '.'
3457                  */
3458                 if (name_len + count_digits(ino) + 1 > BTRFS_NAME_LEN) {
3459                         ret = -EFBIG;
3460                         goto out;
3461                 }
3462                 snprintf(namebuf + name_len, BTRFS_NAME_LEN - name_len,
3463                          ".%llu", ino);
3464                 name_len += count_digits(ino) + 1;
3465                 ret = btrfs_add_link(trans, root, ino, lost_found_ino, namebuf,
3466                                      name_len, filetype, NULL, 1, 0);
3467         }
3468         if (ret < 0) {
3469                 error("failed to link the inode %llu to %s dir: %s",
3470                       ino, dir_name, strerror(-ret));
3471                 goto out;
3472         }
3473
3474         ++*ref_count;
3475         printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
3476                name_len, namebuf, dir_name);
3477 out:
3478         btrfs_release_path(path);
3479         if (ret)
3480                 error("failed to move file '%.*s' to '%s' dir", name_len,
3481                                 namebuf, dir_name);
3482         return ret;
3483 }
3484
3485 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
3486                                struct btrfs_root *root,
3487                                struct btrfs_path *path,
3488                                struct inode_record *rec)
3489 {
3490         char namebuf[BTRFS_NAME_LEN] = {0};
3491         u8 type = 0;
3492         int namelen = 0;
3493         int name_recovered = 0;
3494         int type_recovered = 0;
3495         int ret = 0;
3496
3497         /*
3498          * Get file name and type first before these invalid inode ref
3499          * are deleted by remove_all_invalid_backref()
3500          */
3501         name_recovered = !find_file_name(rec, namebuf, &namelen);
3502         type_recovered = !find_file_type(rec, &type);
3503
3504         if (!name_recovered) {
3505                 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
3506                        rec->ino, rec->ino);
3507                 namelen = count_digits(rec->ino);
3508                 sprintf(namebuf, "%llu", rec->ino);
3509                 name_recovered = 1;
3510         }
3511         if (!type_recovered) {
3512                 printf("Can't get file type for inode %llu, using FILE as fallback\n",
3513                        rec->ino);
3514                 type = BTRFS_FT_REG_FILE;
3515                 type_recovered = 1;
3516         }
3517
3518         ret = reset_nlink(trans, root, path, rec);
3519         if (ret < 0) {
3520                 fprintf(stderr,
3521                         "Failed to reset nlink for inode %llu: %s\n",
3522                         rec->ino, strerror(-ret));
3523                 goto out;
3524         }
3525
3526         if (rec->found_link == 0) {
3527                 ret = link_inode_to_lostfound(trans, root, path, rec->ino,
3528                                               namebuf, namelen, type,
3529                                               (u64 *)&rec->found_link);
3530                 if (ret)
3531                         goto out;
3532         }
3533         printf("Fixed the nlink of inode %llu\n", rec->ino);
3534 out:
3535         /*
3536          * Clear the flag anyway, or we will loop forever for the same inode
3537          * as it will not be removed from the bad inode list and the dead loop
3538          * happens.
3539          */
3540         rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
3541         btrfs_release_path(path);
3542         return ret;
3543 }
3544
3545 /*
3546  * Check if there is any normal(reg or prealloc) file extent for given
3547  * ino.
3548  * This is used to determine the file type when neither its dir_index/item or
3549  * inode_item exists.
3550  *
3551  * This will *NOT* report error, if any error happens, just consider it does
3552  * not have any normal file extent.
3553  */
3554 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
3555 {
3556         struct btrfs_path path;
3557         struct btrfs_key key;
3558         struct btrfs_key found_key;
3559         struct btrfs_file_extent_item *fi;
3560         u8 type;
3561         int ret = 0;
3562
3563         btrfs_init_path(&path);
3564         key.objectid = ino;
3565         key.type = BTRFS_EXTENT_DATA_KEY;
3566         key.offset = 0;
3567
3568         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3569         if (ret < 0) {
3570                 ret = 0;
3571                 goto out;
3572         }
3573         if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
3574                 ret = btrfs_next_leaf(root, &path);
3575                 if (ret) {
3576                         ret = 0;
3577                         goto out;
3578                 }
3579         }
3580         while (1) {
3581                 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3582                                       path.slots[0]);
3583                 if (found_key.objectid != ino ||
3584                     found_key.type != BTRFS_EXTENT_DATA_KEY)
3585                         break;
3586                 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3587                                     struct btrfs_file_extent_item);
3588                 type = btrfs_file_extent_type(path.nodes[0], fi);
3589                 if (type != BTRFS_FILE_EXTENT_INLINE) {
3590                         ret = 1;
3591                         goto out;
3592                 }
3593         }
3594 out:
3595         btrfs_release_path(&path);
3596         return ret;
3597 }
3598
3599 static u32 btrfs_type_to_imode(u8 type)
3600 {
3601         static u32 imode_by_btrfs_type[] = {
3602                 [BTRFS_FT_REG_FILE]     = S_IFREG,
3603                 [BTRFS_FT_DIR]          = S_IFDIR,
3604                 [BTRFS_FT_CHRDEV]       = S_IFCHR,
3605                 [BTRFS_FT_BLKDEV]       = S_IFBLK,
3606                 [BTRFS_FT_FIFO]         = S_IFIFO,
3607                 [BTRFS_FT_SOCK]         = S_IFSOCK,
3608                 [BTRFS_FT_SYMLINK]      = S_IFLNK,
3609         };
3610
3611         return imode_by_btrfs_type[(type)];
3612 }
3613
3614 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3615                                 struct btrfs_root *root,
3616                                 struct btrfs_path *path,
3617                                 struct inode_record *rec)
3618 {
3619         u8 filetype;
3620         u32 mode = 0700;
3621         int type_recovered = 0;
3622         int ret = 0;
3623
3624         printf("Trying to rebuild inode:%llu\n", rec->ino);
3625
3626         type_recovered = !find_file_type(rec, &filetype);
3627
3628         /*
3629          * Try to determine inode type if type not found.
3630          *
3631          * For found regular file extent, it must be FILE.
3632          * For found dir_item/index, it must be DIR.
3633          *
3634          * For undetermined one, use FILE as fallback.
3635          *
3636          * TODO:
3637          * 1. If found backref(inode_index/item is already handled) to it,
3638          *    it must be DIR.
3639          *    Need new inode-inode ref structure to allow search for that.
3640          */
3641         if (!type_recovered) {
3642                 if (rec->found_file_extent &&
3643                     find_normal_file_extent(root, rec->ino)) {
3644                         type_recovered = 1;
3645                         filetype = BTRFS_FT_REG_FILE;
3646                 } else if (rec->found_dir_item) {
3647                         type_recovered = 1;
3648                         filetype = BTRFS_FT_DIR;
3649                 } else if (!list_empty(&rec->orphan_extents)) {
3650                         type_recovered = 1;
3651                         filetype = BTRFS_FT_REG_FILE;
3652                 } else{
3653                         printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3654                                rec->ino);
3655                         type_recovered = 1;
3656                         filetype = BTRFS_FT_REG_FILE;
3657                 }
3658         }
3659
3660         ret = btrfs_new_inode(trans, root, rec->ino,
3661                               mode | btrfs_type_to_imode(filetype));
3662         if (ret < 0)
3663                 goto out;
3664
3665         /*
3666          * Here inode rebuild is done, we only rebuild the inode item,
3667          * don't repair the nlink(like move to lost+found).
3668          * That is the job of nlink repair.
3669          *
3670          * We just fill the record and return
3671          */
3672         rec->found_dir_item = 1;
3673         rec->imode = mode | btrfs_type_to_imode(filetype);
3674         rec->nlink = 0;
3675         rec->errors &= ~I_ERR_NO_INODE_ITEM;
3676         /* Ensure the inode_nlinks repair function will be called */
3677         rec->errors |= I_ERR_LINK_COUNT_WRONG;
3678 out:
3679         return ret;
3680 }
3681
3682 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3683                                       struct btrfs_root *root,
3684                                       struct btrfs_path *path,
3685                                       struct inode_record *rec)
3686 {
3687         struct orphan_data_extent *orphan;
3688         struct orphan_data_extent *tmp;
3689         int ret = 0;
3690
3691         list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3692                 /*
3693                  * Check for conflicting file extents
3694                  *
3695                  * Here we don't know whether the extents is compressed or not,
3696                  * so we can only assume it not compressed nor data offset,
3697                  * and use its disk_len as extent length.
3698                  */
3699                 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3700                                        orphan->offset, orphan->disk_len, 0);
3701                 btrfs_release_path(path);
3702                 if (ret < 0)
3703                         goto out;
3704                 if (!ret) {
3705                         fprintf(stderr,
3706                                 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3707                                 orphan->disk_bytenr, orphan->disk_len);
3708                         ret = btrfs_free_extent(trans,
3709                                         root->fs_info->extent_root,
3710                                         orphan->disk_bytenr, orphan->disk_len,
3711                                         0, root->objectid, orphan->objectid,
3712                                         orphan->offset);
3713                         if (ret < 0)
3714                                 goto out;
3715                 }
3716                 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3717                                 orphan->offset, orphan->disk_bytenr,
3718                                 orphan->disk_len, orphan->disk_len);
3719                 if (ret < 0)
3720                         goto out;
3721
3722                 /* Update file size info */
3723                 rec->found_size += orphan->disk_len;
3724                 if (rec->found_size == rec->nbytes)
3725                         rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3726
3727                 /* Update the file extent hole info too */
3728                 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3729                                            orphan->disk_len);
3730                 if (ret < 0)
3731                         goto out;
3732                 if (RB_EMPTY_ROOT(&rec->holes))
3733                         rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3734
3735                 list_del(&orphan->list);
3736                 free(orphan);
3737         }
3738         rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3739 out:
3740         return ret;
3741 }
3742
3743 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3744                                         struct btrfs_root *root,
3745                                         struct btrfs_path *path,
3746                                         struct inode_record *rec)
3747 {
3748         struct rb_node *node;
3749         struct file_extent_hole *hole;
3750         int found = 0;
3751         int ret = 0;
3752
3753         node = rb_first(&rec->holes);
3754
3755         while (node) {
3756                 found = 1;
3757                 hole = rb_entry(node, struct file_extent_hole, node);
3758                 ret = btrfs_punch_hole(trans, root, rec->ino,
3759                                        hole->start, hole->len);
3760                 if (ret < 0)
3761                         goto out;
3762                 ret = del_file_extent_hole(&rec->holes, hole->start,
3763                                            hole->len);
3764                 if (ret < 0)
3765                         goto out;
3766                 if (RB_EMPTY_ROOT(&rec->holes))
3767                         rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3768                 node = rb_first(&rec->holes);
3769         }
3770         /* special case for a file losing all its file extent */
3771         if (!found) {
3772                 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3773                                        round_up(rec->isize,
3774                                                 root->fs_info->sectorsize));
3775                 if (ret < 0)
3776                         goto out;
3777         }
3778         printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3779                rec->ino, root->objectid);
3780 out:
3781         return ret;
3782 }
3783
3784 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3785 {
3786         struct btrfs_trans_handle *trans;
3787         struct btrfs_path path;
3788         int ret = 0;
3789
3790         if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3791                              I_ERR_NO_ORPHAN_ITEM |
3792                              I_ERR_LINK_COUNT_WRONG |
3793                              I_ERR_NO_INODE_ITEM |
3794                              I_ERR_FILE_EXTENT_ORPHAN |
3795                              I_ERR_FILE_EXTENT_DISCOUNT|
3796                              I_ERR_FILE_NBYTES_WRONG)))
3797                 return rec->errors;
3798
3799         /*
3800          * For nlink repair, it may create a dir and add link, so
3801          * 2 for parent(256)'s dir_index and dir_item
3802          * 2 for lost+found dir's inode_item and inode_ref
3803          * 1 for the new inode_ref of the file
3804          * 2 for lost+found dir's dir_index and dir_item for the file
3805          */
3806         trans = btrfs_start_transaction(root, 7);
3807         if (IS_ERR(trans))
3808                 return PTR_ERR(trans);
3809
3810         btrfs_init_path(&path);
3811         if (rec->errors & I_ERR_NO_INODE_ITEM)
3812                 ret = repair_inode_no_item(trans, root, &path, rec);
3813         if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3814                 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3815         if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3816                 ret = repair_inode_discount_extent(trans, root, &path, rec);
3817         if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3818                 ret = repair_inode_isize(trans, root, &path, rec);
3819         if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3820                 ret = repair_inode_orphan_item(trans, root, &path, rec);
3821         if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3822                 ret = repair_inode_nlinks(trans, root, &path, rec);
3823         if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3824                 ret = repair_inode_nbytes(trans, root, &path, rec);
3825         btrfs_commit_transaction(trans, root);
3826         btrfs_release_path(&path);
3827         return ret;
3828 }
3829
3830 static int check_inode_recs(struct btrfs_root *root,
3831                             struct cache_tree *inode_cache)
3832 {
3833         struct cache_extent *cache;
3834         struct ptr_node *node;
3835         struct inode_record *rec;
3836         struct inode_backref *backref;
3837         int stage = 0;
3838         int ret = 0;
3839         int err = 0;
3840         u64 error = 0;
3841         u64 root_dirid = btrfs_root_dirid(&root->root_item);
3842
3843         if (btrfs_root_refs(&root->root_item) == 0) {
3844                 if (!cache_tree_empty(inode_cache))
3845                         fprintf(stderr, "warning line %d\n", __LINE__);
3846                 return 0;
3847         }
3848
3849         /*
3850          * We need to repair backrefs first because we could change some of the
3851          * errors in the inode recs.
3852          *
3853          * We also need to go through and delete invalid backrefs first and then
3854          * add the correct ones second.  We do this because we may get EEXIST
3855          * when adding back the correct index because we hadn't yet deleted the
3856          * invalid index.
3857          *
3858          * For example, if we were missing a dir index then the directories
3859          * isize would be wrong, so if we fixed the isize to what we thought it
3860          * would be and then fixed the backref we'd still have a invalid fs, so
3861          * we need to add back the dir index and then check to see if the isize
3862          * is still wrong.
3863          */
3864         while (stage < 3) {
3865                 stage++;
3866                 if (stage == 3 && !err)
3867                         break;
3868
3869                 cache = search_cache_extent(inode_cache, 0);
3870                 while (repair && cache) {
3871                         node = container_of(cache, struct ptr_node, cache);
3872                         rec = node->data;
3873                         cache = next_cache_extent(cache);
3874
3875                         /* Need to free everything up and rescan */
3876                         if (stage == 3) {
3877                                 remove_cache_extent(inode_cache, &node->cache);
3878                                 free(node);
3879                                 free_inode_rec(rec);
3880                                 continue;
3881                         }
3882
3883                         if (list_empty(&rec->backrefs))
3884                                 continue;
3885
3886                         ret = repair_inode_backrefs(root, rec, inode_cache,
3887                                                     stage == 1);
3888                         if (ret < 0) {
3889                                 err = ret;
3890                                 stage = 2;
3891                                 break;
3892                         } if (ret > 0) {
3893                                 err = -EAGAIN;
3894                         }
3895                 }
3896         }
3897         if (err)
3898                 return err;
3899
3900         rec = get_inode_rec(inode_cache, root_dirid, 0);
3901         BUG_ON(IS_ERR(rec));
3902         if (rec) {
3903                 ret = check_root_dir(rec);
3904                 if (ret) {
3905                         fprintf(stderr, "root %llu root dir %llu error\n",
3906                                 (unsigned long long)root->root_key.objectid,
3907                                 (unsigned long long)root_dirid);
3908                         print_inode_error(root, rec);
3909                         error++;
3910                 }
3911         } else {
3912                 if (repair) {
3913                         struct btrfs_trans_handle *trans;
3914
3915                         trans = btrfs_start_transaction(root, 1);
3916                         if (IS_ERR(trans)) {
3917                                 err = PTR_ERR(trans);
3918                                 return err;
3919                         }
3920
3921                         fprintf(stderr,
3922                                 "root %llu missing its root dir, recreating\n",
3923                                 (unsigned long long)root->objectid);
3924
3925                         ret = btrfs_make_root_dir(trans, root, root_dirid);
3926                         BUG_ON(ret);
3927
3928                         btrfs_commit_transaction(trans, root);
3929                         return -EAGAIN;
3930                 }
3931
3932                 fprintf(stderr, "root %llu root dir %llu not found\n",
3933                         (unsigned long long)root->root_key.objectid,
3934                         (unsigned long long)root_dirid);
3935         }
3936
3937         while (1) {
3938                 cache = search_cache_extent(inode_cache, 0);
3939                 if (!cache)
3940                         break;
3941                 node = container_of(cache, struct ptr_node, cache);
3942                 rec = node->data;
3943                 remove_cache_extent(inode_cache, &node->cache);
3944                 free(node);
3945                 if (rec->ino == root_dirid ||
3946                     rec->ino == BTRFS_ORPHAN_OBJECTID) {
3947                         free_inode_rec(rec);
3948                         continue;
3949                 }
3950
3951                 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3952                         ret = check_orphan_item(root, rec->ino);
3953                         if (ret == 0)
3954                                 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3955                         if (can_free_inode_rec(rec)) {
3956                                 free_inode_rec(rec);
3957                                 continue;
3958                         }
3959                 }
3960
3961                 if (!rec->found_inode_item)
3962                         rec->errors |= I_ERR_NO_INODE_ITEM;
3963                 if (rec->found_link != rec->nlink)
3964                         rec->errors |= I_ERR_LINK_COUNT_WRONG;
3965                 if (repair) {
3966                         ret = try_repair_inode(root, rec);
3967                         if (ret == 0 && can_free_inode_rec(rec)) {
3968                                 free_inode_rec(rec);
3969                                 continue;
3970                         }
3971                         ret = 0;
3972                 }
3973
3974                 if (!(repair && ret == 0))
3975                         error++;
3976                 print_inode_error(root, rec);
3977                 list_for_each_entry(backref, &rec->backrefs, list) {
3978                         if (!backref->found_dir_item)
3979                                 backref->errors |= REF_ERR_NO_DIR_ITEM;
3980                         if (!backref->found_dir_index)
3981                                 backref->errors |= REF_ERR_NO_DIR_INDEX;
3982                         if (!backref->found_inode_ref)
3983                                 backref->errors |= REF_ERR_NO_INODE_REF;
3984                         fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3985                                 " namelen %u name %s filetype %d errors %x",
3986                                 (unsigned long long)backref->dir,
3987                                 (unsigned long long)backref->index,
3988                                 backref->namelen, backref->name,
3989                                 backref->filetype, backref->errors);
3990                         print_ref_error(backref->errors);
3991                 }
3992                 free_inode_rec(rec);
3993         }
3994         return (error > 0) ? -1 : 0;
3995 }
3996
3997 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3998                                         u64 objectid)
3999 {
4000         struct cache_extent *cache;
4001         struct root_record *rec = NULL;
4002         int ret;
4003
4004         cache = lookup_cache_extent(root_cache, objectid, 1);
4005         if (cache) {
4006                 rec = container_of(cache, struct root_record, cache);
4007         } else {
4008                 rec = calloc(1, sizeof(*rec));
4009                 if (!rec)
4010                         return ERR_PTR(-ENOMEM);
4011                 rec->objectid = objectid;
4012                 INIT_LIST_HEAD(&rec->backrefs);
4013                 rec->cache.start = objectid;
4014                 rec->cache.size = 1;
4015
4016                 ret = insert_cache_extent(root_cache, &rec->cache);
4017                 if (ret)
4018                         return ERR_PTR(-EEXIST);
4019         }
4020         return rec;
4021 }
4022
4023 static struct root_backref *get_root_backref(struct root_record *rec,
4024                                              u64 ref_root, u64 dir, u64 index,
4025                                              const char *name, int namelen)
4026 {
4027         struct root_backref *backref;
4028
4029         list_for_each_entry(backref, &rec->backrefs, list) {
4030                 if (backref->ref_root != ref_root || backref->dir != dir ||
4031                     backref->namelen != namelen)
4032                         continue;
4033                 if (memcmp(name, backref->name, namelen))
4034                         continue;
4035                 return backref;
4036         }
4037
4038         backref = calloc(1, sizeof(*backref) + namelen + 1);
4039         if (!backref)
4040                 return NULL;
4041         backref->ref_root = ref_root;
4042         backref->dir = dir;
4043         backref->index = index;
4044         backref->namelen = namelen;
4045         memcpy(backref->name, name, namelen);
4046         backref->name[namelen] = '\0';
4047         list_add_tail(&backref->list, &rec->backrefs);
4048         return backref;
4049 }
4050
4051 static void free_root_record(struct cache_extent *cache)
4052 {
4053         struct root_record *rec;
4054         struct root_backref *backref;
4055
4056         rec = container_of(cache, struct root_record, cache);
4057         while (!list_empty(&rec->backrefs)) {
4058                 backref = to_root_backref(rec->backrefs.next);
4059                 list_del(&backref->list);
4060                 free(backref);
4061         }
4062
4063         free(rec);
4064 }
4065
4066 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
4067
4068 static int add_root_backref(struct cache_tree *root_cache,
4069                             u64 root_id, u64 ref_root, u64 dir, u64 index,
4070                             const char *name, int namelen,
4071                             int item_type, int errors)
4072 {
4073         struct root_record *rec;
4074         struct root_backref *backref;
4075
4076         rec = get_root_rec(root_cache, root_id);
4077         BUG_ON(IS_ERR(rec));
4078         backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
4079         BUG_ON(!backref);
4080
4081         backref->errors |= errors;
4082
4083         if (item_type != BTRFS_DIR_ITEM_KEY) {
4084                 if (backref->found_dir_index || backref->found_back_ref ||
4085                     backref->found_forward_ref) {
4086                         if (backref->index != index)
4087                                 backref->errors |= REF_ERR_INDEX_UNMATCH;
4088                 } else {
4089                         backref->index = index;
4090                 }
4091         }
4092
4093         if (item_type == BTRFS_DIR_ITEM_KEY) {
4094                 if (backref->found_forward_ref)
4095                         rec->found_ref++;
4096                 backref->found_dir_item = 1;
4097         } else if (item_type == BTRFS_DIR_INDEX_KEY) {
4098                 backref->found_dir_index = 1;
4099         } else if (item_type == BTRFS_ROOT_REF_KEY) {
4100                 if (backref->found_forward_ref)
4101                         backref->errors |= REF_ERR_DUP_ROOT_REF;
4102                 else if (backref->found_dir_item)
4103                         rec->found_ref++;
4104                 backref->found_forward_ref = 1;
4105         } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
4106                 if (backref->found_back_ref)
4107                         backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
4108                 backref->found_back_ref = 1;
4109         } else {
4110                 BUG_ON(1);
4111         }
4112
4113         if (backref->found_forward_ref && backref->found_dir_item)
4114                 backref->reachable = 1;
4115         return 0;
4116 }
4117
4118 static int merge_root_recs(struct btrfs_root *root,
4119                            struct cache_tree *src_cache,
4120                            struct cache_tree *dst_cache)
4121 {
4122         struct cache_extent *cache;
4123         struct ptr_node *node;
4124         struct inode_record *rec;
4125         struct inode_backref *backref;
4126         int ret = 0;
4127
4128         if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4129                 free_inode_recs_tree(src_cache);
4130                 return 0;
4131         }
4132
4133         while (1) {
4134                 cache = search_cache_extent(src_cache, 0);
4135                 if (!cache)
4136                         break;
4137                 node = container_of(cache, struct ptr_node, cache);
4138                 rec = node->data;
4139                 remove_cache_extent(src_cache, &node->cache);
4140                 free(node);
4141
4142                 ret = is_child_root(root, root->objectid, rec->ino);
4143                 if (ret < 0)
4144                         break;
4145                 else if (ret == 0)
4146                         goto skip;
4147
4148                 list_for_each_entry(backref, &rec->backrefs, list) {
4149                         BUG_ON(backref->found_inode_ref);
4150                         if (backref->found_dir_item)
4151                                 add_root_backref(dst_cache, rec->ino,
4152                                         root->root_key.objectid, backref->dir,
4153                                         backref->index, backref->name,
4154                                         backref->namelen, BTRFS_DIR_ITEM_KEY,
4155                                         backref->errors);
4156                         if (backref->found_dir_index)
4157                                 add_root_backref(dst_cache, rec->ino,
4158                                         root->root_key.objectid, backref->dir,
4159                                         backref->index, backref->name,
4160                                         backref->namelen, BTRFS_DIR_INDEX_KEY,
4161                                         backref->errors);
4162                 }
4163 skip:
4164                 free_inode_rec(rec);
4165         }
4166         if (ret < 0)
4167                 return ret;
4168         return 0;
4169 }
4170
4171 static int check_root_refs(struct btrfs_root *root,
4172                            struct cache_tree *root_cache)
4173 {
4174         struct root_record *rec;
4175         struct root_record *ref_root;
4176         struct root_backref *backref;
4177         struct cache_extent *cache;
4178         int loop = 1;
4179         int ret;
4180         int error;
4181         int errors = 0;
4182
4183         rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
4184         BUG_ON(IS_ERR(rec));
4185         rec->found_ref = 1;
4186
4187         /* fixme: this can not detect circular references */
4188         while (loop) {
4189                 loop = 0;
4190                 cache = search_cache_extent(root_cache, 0);
4191                 while (1) {
4192                         if (!cache)
4193                                 break;
4194                         rec = container_of(cache, struct root_record, cache);
4195                         cache = next_cache_extent(cache);
4196
4197                         if (rec->found_ref == 0)
4198                                 continue;
4199
4200                         list_for_each_entry(backref, &rec->backrefs, list) {
4201                                 if (!backref->reachable)
4202                                         continue;
4203
4204                                 ref_root = get_root_rec(root_cache,
4205                                                         backref->ref_root);
4206                                 BUG_ON(IS_ERR(ref_root));
4207                                 if (ref_root->found_ref > 0)
4208                                         continue;
4209
4210                                 backref->reachable = 0;
4211                                 rec->found_ref--;
4212                                 if (rec->found_ref == 0)
4213                                         loop = 1;
4214                         }
4215                 }
4216         }
4217
4218         cache = search_cache_extent(root_cache, 0);
4219         while (1) {
4220                 if (!cache)
4221                         break;
4222                 rec = container_of(cache, struct root_record, cache);
4223                 cache = next_cache_extent(cache);
4224
4225                 if (rec->found_ref == 0 &&
4226                     rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
4227                     rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
4228                         ret = check_orphan_item(root->fs_info->tree_root,
4229                                                 rec->objectid);
4230                         if (ret == 0)
4231                                 continue;
4232
4233                         /*
4234                          * If we don't have a root item then we likely just have
4235                          * a dir item in a snapshot for this root but no actual
4236                          * ref key or anything so it's meaningless.
4237                          */
4238                         if (!rec->found_root_item)
4239                                 continue;
4240                         errors++;
4241                         fprintf(stderr, "fs tree %llu not referenced\n",
4242                                 (unsigned long long)rec->objectid);
4243                 }
4244
4245                 error = 0;
4246                 if (rec->found_ref > 0 && !rec->found_root_item)
4247                         error = 1;
4248                 list_for_each_entry(backref, &rec->backrefs, list) {
4249                         if (!backref->found_dir_item)
4250                                 backref->errors |= REF_ERR_NO_DIR_ITEM;
4251                         if (!backref->found_dir_index)
4252                                 backref->errors |= REF_ERR_NO_DIR_INDEX;
4253                         if (!backref->found_back_ref)
4254                                 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
4255                         if (!backref->found_forward_ref)
4256                                 backref->errors |= REF_ERR_NO_ROOT_REF;
4257                         if (backref->reachable && backref->errors)
4258                                 error = 1;
4259                 }
4260                 if (!error)
4261                         continue;
4262
4263                 errors++;
4264                 fprintf(stderr, "fs tree %llu refs %u %s\n",
4265                         (unsigned long long)rec->objectid, rec->found_ref,
4266                          rec->found_root_item ? "" : "not found");
4267
4268                 list_for_each_entry(backref, &rec->backrefs, list) {
4269                         if (!backref->reachable)
4270                                 continue;
4271                         if (!backref->errors && rec->found_root_item)
4272                                 continue;
4273                         fprintf(stderr, "\tunresolved ref root %llu dir %llu"
4274                                 " index %llu namelen %u name %s errors %x\n",
4275                                 (unsigned long long)backref->ref_root,
4276                                 (unsigned long long)backref->dir,
4277                                 (unsigned long long)backref->index,
4278                                 backref->namelen, backref->name,
4279                                 backref->errors);
4280                         print_ref_error(backref->errors);
4281                 }
4282         }
4283         return errors > 0 ? 1 : 0;
4284 }
4285
4286 static int process_root_ref(struct extent_buffer *eb, int slot,
4287                             struct btrfs_key *key,
4288                             struct cache_tree *root_cache)
4289 {
4290         u64 dirid;
4291         u64 index;
4292         u32 len;
4293         u32 name_len;
4294         struct btrfs_root_ref *ref;
4295         char namebuf[BTRFS_NAME_LEN];
4296         int error;
4297
4298         ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
4299
4300         dirid = btrfs_root_ref_dirid(eb, ref);
4301         index = btrfs_root_ref_sequence(eb, ref);
4302         name_len = btrfs_root_ref_name_len(eb, ref);
4303
4304         if (name_len <= BTRFS_NAME_LEN) {
4305                 len = name_len;
4306                 error = 0;
4307         } else {
4308                 len = BTRFS_NAME_LEN;
4309                 error = REF_ERR_NAME_TOO_LONG;
4310         }
4311         read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
4312
4313         if (key->type == BTRFS_ROOT_REF_KEY) {
4314                 add_root_backref(root_cache, key->offset, key->objectid, dirid,
4315                                  index, namebuf, len, key->type, error);
4316         } else {
4317                 add_root_backref(root_cache, key->objectid, key->offset, dirid,
4318                                  index, namebuf, len, key->type, error);
4319         }
4320         return 0;
4321 }
4322
4323 static void free_corrupt_block(struct cache_extent *cache)
4324 {
4325         struct btrfs_corrupt_block *corrupt;
4326
4327         corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
4328         free(corrupt);
4329 }
4330
4331 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
4332
4333 /*
4334  * Repair the btree of the given root.
4335  *
4336  * The fix is to remove the node key in corrupt_blocks cache_tree.
4337  * and rebalance the tree.
4338  * After the fix, the btree should be writeable.
4339  */
4340 static int repair_btree(struct btrfs_root *root,
4341                         struct cache_tree *corrupt_blocks)
4342 {
4343         struct btrfs_trans_handle *trans;
4344         struct btrfs_path path;
4345         struct btrfs_corrupt_block *corrupt;
4346         struct cache_extent *cache;
4347         struct btrfs_key key;
4348         u64 offset;
4349         int level;
4350         int ret = 0;
4351
4352         if (cache_tree_empty(corrupt_blocks))
4353                 return 0;
4354
4355         trans = btrfs_start_transaction(root, 1);
4356         if (IS_ERR(trans)) {
4357                 ret = PTR_ERR(trans);
4358                 fprintf(stderr, "Error starting transaction: %s\n",
4359                         strerror(-ret));
4360                 return ret;
4361         }
4362         btrfs_init_path(&path);
4363         cache = first_cache_extent(corrupt_blocks);
4364         while (cache) {
4365                 corrupt = container_of(cache, struct btrfs_corrupt_block,
4366                                        cache);
4367                 level = corrupt->level;
4368                 path.lowest_level = level;
4369                 key.objectid = corrupt->key.objectid;
4370                 key.type = corrupt->key.type;
4371                 key.offset = corrupt->key.offset;
4372
4373                 /*
4374                  * Here we don't want to do any tree balance, since it may
4375                  * cause a balance with corrupted brother leaf/node,
4376                  * so ins_len set to 0 here.
4377                  * Balance will be done after all corrupt node/leaf is deleted.
4378                  */
4379                 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
4380                 if (ret < 0)
4381                         goto out;
4382                 offset = btrfs_node_blockptr(path.nodes[level],
4383                                              path.slots[level]);
4384
4385                 /* Remove the ptr */
4386                 ret = btrfs_del_ptr(root, &path, level, path.slots[level]);
4387                 if (ret < 0)
4388                         goto out;
4389                 /*
4390                  * Remove the corresponding extent
4391                  * return value is not concerned.
4392                  */
4393                 btrfs_release_path(&path);
4394                 ret = btrfs_free_extent(trans, root, offset,
4395                                 root->fs_info->nodesize, 0,
4396                                 root->root_key.objectid, level - 1, 0);
4397                 cache = next_cache_extent(cache);
4398         }
4399
4400         /* Balance the btree using btrfs_search_slot() */
4401         cache = first_cache_extent(corrupt_blocks);
4402         while (cache) {
4403                 corrupt = container_of(cache, struct btrfs_corrupt_block,
4404                                        cache);
4405                 memcpy(&key, &corrupt->key, sizeof(key));
4406                 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
4407                 if (ret < 0)
4408                         goto out;
4409                 /* return will always >0 since it won't find the item */
4410                 ret = 0;
4411                 btrfs_release_path(&path);
4412                 cache = next_cache_extent(cache);
4413         }
4414 out:
4415         btrfs_commit_transaction(trans, root);
4416         btrfs_release_path(&path);
4417         return ret;
4418 }
4419
4420 static int check_fs_root(struct btrfs_root *root,
4421                          struct cache_tree *root_cache,
4422                          struct walk_control *wc)
4423 {
4424         int ret = 0;
4425         int err = 0;
4426         int wret;
4427         int level;
4428         struct btrfs_path path;
4429         struct shared_node root_node;
4430         struct root_record *rec;
4431         struct btrfs_root_item *root_item = &root->root_item;
4432         struct cache_tree corrupt_blocks;
4433         struct orphan_data_extent *orphan;
4434         struct orphan_data_extent *tmp;
4435         enum btrfs_tree_block_status status;
4436         struct node_refs nrefs;
4437
4438         /*
4439          * Reuse the corrupt_block cache tree to record corrupted tree block
4440          *
4441          * Unlike the usage in extent tree check, here we do it in a per
4442          * fs/subvol tree base.
4443          */
4444         cache_tree_init(&corrupt_blocks);
4445         root->fs_info->corrupt_blocks = &corrupt_blocks;
4446
4447         if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
4448                 rec = get_root_rec(root_cache, root->root_key.objectid);
4449                 BUG_ON(IS_ERR(rec));
4450                 if (btrfs_root_refs(root_item) > 0)
4451                         rec->found_root_item = 1;
4452         }
4453
4454         btrfs_init_path(&path);
4455         memset(&root_node, 0, sizeof(root_node));
4456         cache_tree_init(&root_node.root_cache);
4457         cache_tree_init(&root_node.inode_cache);
4458         memset(&nrefs, 0, sizeof(nrefs));
4459
4460         /* Move the orphan extent record to corresponding inode_record */
4461         list_for_each_entry_safe(orphan, tmp,
4462                                  &root->orphan_data_extents, list) {
4463                 struct inode_record *inode;
4464
4465                 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
4466                                       1);
4467                 BUG_ON(IS_ERR(inode));
4468                 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
4469                 list_move(&orphan->list, &inode->orphan_extents);
4470         }
4471
4472         level = btrfs_header_level(root->node);
4473         memset(wc->nodes, 0, sizeof(wc->nodes));
4474         wc->nodes[level] = &root_node;
4475         wc->active_node = level;
4476         wc->root_level = level;
4477
4478         /* We may not have checked the root block, lets do that now */
4479         if (btrfs_is_leaf(root->node))
4480                 status = btrfs_check_leaf(root, NULL, root->node);
4481         else
4482                 status = btrfs_check_node(root, NULL, root->node);
4483         if (status != BTRFS_TREE_BLOCK_CLEAN)
4484                 return -EIO;
4485
4486         if (btrfs_root_refs(root_item) > 0 ||
4487             btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
4488                 path.nodes[level] = root->node;
4489                 extent_buffer_get(root->node);
4490                 path.slots[level] = 0;
4491         } else {
4492                 struct btrfs_key key;
4493                 struct btrfs_disk_key found_key;
4494
4495                 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
4496                 level = root_item->drop_level;
4497                 path.lowest_level = level;
4498                 if (level > btrfs_header_level(root->node) ||
4499                     level >= BTRFS_MAX_LEVEL) {
4500                         error("ignoring invalid drop level: %u", level);
4501                         goto skip_walking;
4502                 }
4503                 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4504                 if (wret < 0)
4505                         goto skip_walking;
4506                 btrfs_node_key(path.nodes[level], &found_key,
4507                                 path.slots[level]);
4508                 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
4509                                         sizeof(found_key)));
4510         }
4511
4512         while (1) {
4513                 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
4514                 if (wret < 0)
4515                         ret = wret;
4516                 if (wret != 0)
4517                         break;
4518
4519                 wret = walk_up_tree(root, &path, wc, &level);
4520                 if (wret < 0)
4521                         ret = wret;
4522                 if (wret != 0)
4523                         break;
4524         }
4525 skip_walking:
4526         btrfs_release_path(&path);
4527
4528         if (!cache_tree_empty(&corrupt_blocks)) {
4529                 struct cache_extent *cache;
4530                 struct btrfs_corrupt_block *corrupt;
4531
4532                 printf("The following tree block(s) is corrupted in tree %llu:\n",
4533                        root->root_key.objectid);
4534                 cache = first_cache_extent(&corrupt_blocks);
4535                 while (cache) {
4536                         corrupt = container_of(cache,
4537                                                struct btrfs_corrupt_block,
4538                                                cache);
4539                         printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
4540                                cache->start, corrupt->level,
4541                                corrupt->key.objectid, corrupt->key.type,
4542                                corrupt->key.offset);
4543                         cache = next_cache_extent(cache);
4544                 }
4545                 if (repair) {
4546                         printf("Try to repair the btree for root %llu\n",
4547                                root->root_key.objectid);
4548                         ret = repair_btree(root, &corrupt_blocks);
4549                         if (ret < 0)
4550                                 fprintf(stderr, "Failed to repair btree: %s\n",
4551                                         strerror(-ret));
4552                         if (!ret)
4553                                 printf("Btree for root %llu is fixed\n",
4554                                        root->root_key.objectid);
4555                 }
4556         }
4557
4558         err = merge_root_recs(root, &root_node.root_cache, root_cache);
4559         if (err < 0)
4560                 ret = err;
4561
4562         if (root_node.current) {
4563                 root_node.current->checked = 1;
4564                 maybe_free_inode_rec(&root_node.inode_cache,
4565                                 root_node.current);
4566         }
4567
4568         err = check_inode_recs(root, &root_node.inode_cache);
4569         if (!ret)
4570                 ret = err;
4571
4572         free_corrupt_blocks_tree(&corrupt_blocks);
4573         root->fs_info->corrupt_blocks = NULL;
4574         free_orphan_data_extents(&root->orphan_data_extents);
4575         return ret;
4576 }
4577
4578 static int fs_root_objectid(u64 objectid)
4579 {
4580         if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4581             objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4582                 return 1;
4583         return is_fstree(objectid);
4584 }
4585
4586 static int check_fs_roots(struct btrfs_fs_info *fs_info,
4587                           struct cache_tree *root_cache)
4588 {
4589         struct btrfs_path path;
4590         struct btrfs_key key;
4591         struct walk_control wc;
4592         struct extent_buffer *leaf, *tree_node;
4593         struct btrfs_root *tmp_root;
4594         struct btrfs_root *tree_root = fs_info->tree_root;
4595         int ret;
4596         int err = 0;
4597
4598         if (ctx.progress_enabled) {
4599                 ctx.tp = TASK_FS_ROOTS;
4600                 task_start(ctx.info);
4601         }
4602
4603         /*
4604          * Just in case we made any changes to the extent tree that weren't
4605          * reflected into the free space cache yet.
4606          */
4607         if (repair)
4608                 reset_cached_block_groups(fs_info);
4609         memset(&wc, 0, sizeof(wc));
4610         cache_tree_init(&wc.shared);
4611         btrfs_init_path(&path);
4612
4613 again:
4614         key.offset = 0;
4615         key.objectid = 0;
4616         key.type = BTRFS_ROOT_ITEM_KEY;
4617         ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4618         if (ret < 0) {
4619                 err = 1;
4620                 goto out;
4621         }
4622         tree_node = tree_root->node;
4623         while (1) {
4624                 if (tree_node != tree_root->node) {
4625                         free_root_recs_tree(root_cache);
4626                         btrfs_release_path(&path);
4627                         goto again;
4628                 }
4629                 leaf = path.nodes[0];
4630                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4631                         ret = btrfs_next_leaf(tree_root, &path);
4632                         if (ret) {
4633                                 if (ret < 0)
4634                                         err = 1;
4635                                 break;
4636                         }
4637                         leaf = path.nodes[0];
4638                 }
4639                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4640                 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4641                     fs_root_objectid(key.objectid)) {
4642                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4643                                 tmp_root = btrfs_read_fs_root_no_cache(
4644                                                 fs_info, &key);
4645                         } else {
4646                                 key.offset = (u64)-1;
4647                                 tmp_root = btrfs_read_fs_root(
4648                                                 fs_info, &key);
4649                         }
4650                         if (IS_ERR(tmp_root)) {
4651                                 err = 1;
4652                                 goto next;
4653                         }
4654                         ret = check_fs_root(tmp_root, root_cache, &wc);
4655                         if (ret == -EAGAIN) {
4656                                 free_root_recs_tree(root_cache);
4657                                 btrfs_release_path(&path);
4658                                 goto again;
4659                         }
4660                         if (ret)
4661                                 err = 1;
4662                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4663                                 btrfs_free_fs_root(tmp_root);
4664                 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4665                            key.type == BTRFS_ROOT_BACKREF_KEY) {
4666                         process_root_ref(leaf, path.slots[0], &key,
4667                                          root_cache);
4668                 }
4669 next:
4670                 path.slots[0]++;
4671         }
4672 out:
4673         btrfs_release_path(&path);
4674         if (err)
4675                 free_extent_cache_tree(&wc.shared);
4676         if (!cache_tree_empty(&wc.shared))
4677                 fprintf(stderr, "warning line %d\n", __LINE__);
4678
4679         task_stop(ctx.info);
4680
4681         return err;
4682 }
4683
4684 /*
4685  * Find the @index according by @ino and name.
4686  * Notice:time efficiency is O(N)
4687  *
4688  * @root:       the root of the fs/file tree
4689  * @index_ret:  the index as return value
4690  * @namebuf:    the name to match
4691  * @name_len:   the length of name to match
4692  * @file_type:  the file_type of INODE_ITEM to match
4693  *
4694  * Returns 0 if found and *@index_ret will be modified with right value
4695  * Returns< 0 not found and *@index_ret will be (u64)-1
4696  */
4697 static int find_dir_index(struct btrfs_root *root, u64 dirid, u64 location_id,
4698                           u64 *index_ret, char *namebuf, u32 name_len,
4699                           u8 file_type)
4700 {
4701         struct btrfs_path path;
4702         struct extent_buffer *node;
4703         struct btrfs_dir_item *di;
4704         struct btrfs_key key;
4705         struct btrfs_key location;
4706         char name[BTRFS_NAME_LEN] = {0};
4707
4708         u32 total;
4709         u32 cur = 0;
4710         u32 len;
4711         u32 data_len;
4712         u8 filetype;
4713         int slot;
4714         int ret;
4715
4716         ASSERT(index_ret);
4717
4718         /* search from the last index */
4719         key.objectid = dirid;
4720         key.offset = (u64)-1;
4721         key.type = BTRFS_DIR_INDEX_KEY;
4722
4723         btrfs_init_path(&path);
4724         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4725         if (ret < 0)
4726                 return ret;
4727
4728 loop:
4729         ret = btrfs_previous_item(root, &path, dirid, BTRFS_DIR_INDEX_KEY);
4730         if (ret) {
4731                 ret = -ENOENT;
4732                 *index_ret = (64)-1;
4733                 goto out;
4734         }
4735         /* Check whether inode_id/filetype/name match */
4736         node = path.nodes[0];
4737         slot = path.slots[0];
4738         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4739         total = btrfs_item_size_nr(node, slot);
4740         while (cur < total) {
4741                 ret = -ENOENT;
4742                 len = btrfs_dir_name_len(node, di);
4743                 data_len = btrfs_dir_data_len(node, di);
4744
4745                 btrfs_dir_item_key_to_cpu(node, di, &location);
4746                 if (location.objectid != location_id ||
4747                     location.type != BTRFS_INODE_ITEM_KEY ||
4748                     location.offset != 0)
4749                         goto next;
4750
4751                 filetype = btrfs_dir_type(node, di);
4752                 if (file_type != filetype)
4753                         goto next;
4754
4755                 if (len > BTRFS_NAME_LEN)
4756                         len = BTRFS_NAME_LEN;
4757
4758                 read_extent_buffer(node, name, (unsigned long)(di + 1), len);
4759                 if (len != name_len || strncmp(namebuf, name, len))
4760                         goto next;
4761
4762                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
4763                 *index_ret = key.offset;
4764                 ret = 0;
4765                 goto out;
4766 next:
4767                 len += sizeof(*di) + data_len;
4768                 di = (struct btrfs_dir_item *)((char *)di + len);
4769                 cur += len;
4770         }
4771         goto loop;
4772
4773 out:
4774         btrfs_release_path(&path);
4775         return ret;
4776 }
4777
4778 /*
4779  * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4780  * INODE_REF/INODE_EXTREF match.
4781  *
4782  * @root:       the root of the fs/file tree
4783  * @key:        the key of the DIR_ITEM/DIR_INDEX, key->offset will be right
4784  *              value while find index
4785  * @location_key: location key of the struct btrfs_dir_item to match
4786  * @name:       the name to match
4787  * @namelen:    the length of name
4788  * @file_type:  the type of file to math
4789  *
4790  * Return 0 if no error occurred.
4791  * Return DIR_ITEM_MISSING/DIR_INDEX_MISSING if couldn't find
4792  * DIR_ITEM/DIR_INDEX
4793  * Return DIR_ITEM_MISMATCH/DIR_INDEX_MISMATCH if INODE_REF/INODE_EXTREF
4794  * and DIR_ITEM/DIR_INDEX mismatch
4795  */
4796 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4797                          struct btrfs_key *location_key, char *name,
4798                          u32 namelen, u8 file_type)
4799 {
4800         struct btrfs_path path;
4801         struct extent_buffer *node;
4802         struct btrfs_dir_item *di;
4803         struct btrfs_key location;
4804         char namebuf[BTRFS_NAME_LEN] = {0};
4805         u32 total;
4806         u32 cur = 0;
4807         u32 len;
4808         u32 data_len;
4809         u8 filetype;
4810         int slot;
4811         int ret;
4812
4813         /* get the index by traversing all index */
4814         if (key->type == BTRFS_DIR_INDEX_KEY && key->offset == (u64)-1) {
4815                 ret = find_dir_index(root, key->objectid,
4816                                      location_key->objectid, &key->offset,
4817                                      name, namelen, file_type);
4818                 if (ret)
4819                         ret = DIR_INDEX_MISSING;
4820                 return ret;
4821         }
4822
4823         btrfs_init_path(&path);
4824         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4825         if (ret) {
4826                 ret = key->type == BTRFS_DIR_ITEM_KEY ? DIR_ITEM_MISSING :
4827                         DIR_INDEX_MISSING;
4828                 goto out;
4829         }
4830
4831         /* Check whether inode_id/filetype/name match */
4832         node = path.nodes[0];
4833         slot = path.slots[0];
4834         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4835         total = btrfs_item_size_nr(node, slot);
4836         while (cur < total) {
4837                 ret = key->type == BTRFS_DIR_ITEM_KEY ?
4838                         DIR_ITEM_MISMATCH : DIR_INDEX_MISMATCH;
4839
4840                 len = btrfs_dir_name_len(node, di);
4841                 data_len = btrfs_dir_data_len(node, di);
4842
4843                 btrfs_dir_item_key_to_cpu(node, di, &location);
4844                 if (location.objectid != location_key->objectid ||
4845                     location.type != location_key->type ||
4846                     location.offset != location_key->offset)
4847                         goto next;
4848
4849                 filetype = btrfs_dir_type(node, di);
4850                 if (file_type != filetype)
4851                         goto next;
4852
4853                 if (len > BTRFS_NAME_LEN) {
4854                         len = BTRFS_NAME_LEN;
4855                         warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4856                         root->objectid,
4857                         key->type == BTRFS_DIR_ITEM_KEY ?
4858                         "DIR_ITEM" : "DIR_INDEX",
4859                         key->objectid, key->offset, len);
4860                 }
4861                 read_extent_buffer(node, namebuf, (unsigned long)(di + 1),
4862                                    len);
4863                 if (len != namelen || strncmp(namebuf, name, len))
4864                         goto next;
4865
4866                 ret = 0;
4867                 goto out;
4868 next:
4869                 len += sizeof(*di) + data_len;
4870                 di = (struct btrfs_dir_item *)((char *)di + len);
4871                 cur += len;
4872         }
4873
4874 out:
4875         btrfs_release_path(&path);
4876         return ret;
4877 }
4878
4879 /*
4880  * Prints inode ref error message
4881  */
4882 static void print_inode_ref_err(struct btrfs_root *root, struct btrfs_key *key,
4883                                 u64 index, const char *namebuf, int name_len,
4884                                 u8 filetype, int err)
4885 {
4886         if (!err)
4887                 return;
4888
4889         /* root dir error */
4890         if (key->objectid == BTRFS_FIRST_FREE_OBJECTID) {
4891                 error(
4892         "root %llu root dir shouldn't have INODE REF[%llu %llu] name %s",
4893                       root->objectid, key->objectid, key->offset, namebuf);
4894                 return;
4895         }
4896
4897         /* normal error */
4898         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING))
4899                 error("root %llu DIR ITEM[%llu %llu] %s name %s filetype %u",
4900                       root->objectid, key->offset,
4901                       btrfs_name_hash(namebuf, name_len),
4902                       err & DIR_ITEM_MISMATCH ? "mismatch" : "missing",
4903                       namebuf, filetype);
4904         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING))
4905                 error("root %llu DIR INDEX[%llu %llu] %s name %s filetype %u",
4906                       root->objectid, key->offset, index,
4907                       err & DIR_ITEM_MISMATCH ? "mismatch" : "missing",
4908                       namebuf, filetype);
4909 }
4910
4911 /*
4912  * Insert the missing inode item.
4913  *
4914  * Returns 0 means success.
4915  * Returns <0 means error.
4916  */
4917 static int repair_inode_item_missing(struct btrfs_root *root, u64 ino,
4918                                      u8 filetype)
4919 {
4920         struct btrfs_key key;
4921         struct btrfs_trans_handle *trans;
4922         struct btrfs_path path;
4923         int ret;
4924
4925         key.objectid = ino;
4926         key.type = BTRFS_INODE_ITEM_KEY;
4927         key.offset = 0;
4928
4929         btrfs_init_path(&path);
4930         trans = btrfs_start_transaction(root, 1);
4931         if (IS_ERR(trans)) {
4932                 ret = -EIO;
4933                 goto out;
4934         }
4935
4936         ret = btrfs_search_slot(trans, root, &key, &path, 1, 1);
4937         if (ret < 0 || !ret)
4938                 goto fail;
4939
4940         /* insert inode item */
4941         create_inode_item_lowmem(trans, root, ino, filetype);
4942         ret = 0;
4943 fail:
4944         btrfs_commit_transaction(trans, root);
4945 out:
4946         if (ret)
4947                 error("failed to repair root %llu INODE ITEM[%llu] missing",
4948                       root->objectid, ino);
4949         btrfs_release_path(&path);
4950         return ret;
4951 }
4952
4953 /*
4954  * The ternary means dir item, dir index and relative inode ref.
4955  * The function handles errs: INODE_MISSING, DIR_INDEX_MISSING
4956  * DIR_INDEX_MISMATCH, DIR_ITEM_MISSING, DIR_ITEM_MISMATCH by the follow
4957  * strategy:
4958  * If two of three is missing or mismatched, delete the existing one.
4959  * If one of three is missing or mismatched, add the missing one.
4960  *
4961  * returns 0 means success.
4962  * returns not 0 means on error;
4963  */
4964 int repair_ternary_lowmem(struct btrfs_root *root, u64 dir_ino, u64 ino,
4965                           u64 index, char *name, int name_len, u8 filetype,
4966                           int err)
4967 {
4968         struct btrfs_trans_handle *trans;
4969         int stage = 0;
4970         int ret = 0;
4971
4972         /*
4973          * stage shall be one of following valild values:
4974          *      0: Fine, nothing to do.
4975          *      1: One of three is wrong, so add missing one.
4976          *      2: Two of three is wrong, so delete existed one.
4977          */
4978         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING))
4979                 stage++;
4980         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING))
4981                 stage++;
4982         if (err & (INODE_REF_MISSING))
4983                 stage++;
4984
4985         /* stage must be smllarer than 3 */
4986         ASSERT(stage < 3);
4987
4988         trans = btrfs_start_transaction(root, 1);
4989         if (stage == 2) {
4990                 ret = btrfs_unlink(trans, root, ino, dir_ino, index, name,
4991                                    name_len, 0);
4992                 goto out;
4993         }
4994         if (stage == 1) {
4995                 ret = btrfs_add_link(trans, root, ino, dir_ino, name, name_len,
4996                                filetype, &index, 1, 1);
4997                 goto out;
4998         }
4999 out:
5000         btrfs_commit_transaction(trans, root);
5001
5002         if (ret)
5003                 error("fail to repair inode %llu name %s filetype %u",
5004                       ino, name, filetype);
5005         else
5006                 printf("%s ref/dir_item of inode %llu name %s filetype %u\n",
5007                        stage == 2 ? "Delete" : "Add",
5008                        ino, name, filetype);
5009
5010         return ret;
5011 }
5012
5013 /*
5014  * Traverse the given INODE_REF and call find_dir_item() to find related
5015  * DIR_ITEM/DIR_INDEX.
5016  *
5017  * @root:       the root of the fs/file tree
5018  * @ref_key:    the key of the INODE_REF
5019  * @path        the path provides node and slot
5020  * @refs:       the count of INODE_REF
5021  * @mode:       the st_mode of INODE_ITEM
5022  * @name_ret:   returns with the first ref's name
5023  * @name_len_ret:    len of the name_ret
5024  *
5025  * Return 0 if no error occurred.
5026  */
5027 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5028                            struct btrfs_path *path, char *name_ret,
5029                            u32 *namelen_ret, u64 *refs_ret, int mode)
5030 {
5031         struct btrfs_key key;
5032         struct btrfs_key location;
5033         struct btrfs_inode_ref *ref;
5034         struct extent_buffer *node;
5035         char namebuf[BTRFS_NAME_LEN] = {0};
5036         u32 total;
5037         u32 cur = 0;
5038         u32 len;
5039         u32 name_len;
5040         u64 index;
5041         int ret;
5042         int err = 0;
5043         int tmp_err;
5044         int slot;
5045         int need_research = 0;
5046         u64 refs;
5047
5048 begin:
5049         err = 0;
5050         cur = 0;
5051         refs = *refs_ret;
5052
5053         /* since after repair, path and the dir item may be changed */
5054         if (need_research) {
5055                 need_research = 0;
5056                 btrfs_release_path(path);
5057                 ret = btrfs_search_slot(NULL, root, ref_key, path, 0, 0);
5058                 /* the item was deleted, let path point to the last checked item */
5059                 if (ret > 0) {
5060                         if (path->slots[0] == 0)
5061                                 btrfs_prev_leaf(root, path);
5062                         else
5063                                 path->slots[0]--;
5064                 }
5065                 if (ret)
5066                         goto out;
5067         }
5068
5069         location.objectid = ref_key->objectid;
5070         location.type = BTRFS_INODE_ITEM_KEY;
5071         location.offset = 0;
5072         node = path->nodes[0];
5073         slot = path->slots[0];
5074
5075         memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
5076         ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
5077         total = btrfs_item_size_nr(node, slot);
5078
5079 next:
5080         /* Update inode ref count */
5081         refs++;
5082         tmp_err = 0;
5083         index = btrfs_inode_ref_index(node, ref);
5084         name_len = btrfs_inode_ref_name_len(node, ref);
5085
5086         if (name_len <= BTRFS_NAME_LEN) {
5087                 len = name_len;
5088         } else {
5089                 len = BTRFS_NAME_LEN;
5090                 warning("root %llu INODE_REF[%llu %llu] name too long",
5091                         root->objectid, ref_key->objectid, ref_key->offset);
5092         }
5093
5094         read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
5095
5096         /* copy the first name found to name_ret */
5097         if (refs == 1 && name_ret) {
5098                 memcpy(name_ret, namebuf, len);
5099                 *namelen_ret = len;
5100         }
5101
5102         /* Check root dir ref */
5103         if (ref_key->objectid == BTRFS_FIRST_FREE_OBJECTID) {
5104                 if (index != 0 || len != strlen("..") ||
5105                     strncmp("..", namebuf, len) ||
5106                     ref_key->offset != BTRFS_FIRST_FREE_OBJECTID) {
5107                         /* set err bits then repair will delete the ref */
5108                         err |= DIR_INDEX_MISSING;
5109                         err |= DIR_ITEM_MISSING;
5110                 }
5111                 goto end;
5112         }
5113
5114         /* Find related DIR_INDEX */
5115         key.objectid = ref_key->offset;
5116         key.type = BTRFS_DIR_INDEX_KEY;
5117         key.offset = index;
5118         tmp_err |= find_dir_item(root, &key, &location, namebuf, len,
5119                             imode_to_type(mode));
5120
5121         /* Find related dir_item */
5122         key.objectid = ref_key->offset;
5123         key.type = BTRFS_DIR_ITEM_KEY;
5124         key.offset = btrfs_name_hash(namebuf, len);
5125         tmp_err |= find_dir_item(root, &key, &location, namebuf, len,
5126                             imode_to_type(mode));
5127 end:
5128         if (tmp_err && repair) {
5129                 ret = repair_ternary_lowmem(root, ref_key->offset,
5130                                             ref_key->objectid, index, namebuf,
5131                                             name_len, imode_to_type(mode),
5132                                             tmp_err);
5133                 if (!ret) {
5134                         need_research = 1;
5135                         goto begin;
5136                 }
5137         }
5138         print_inode_ref_err(root, ref_key, index, namebuf, name_len,
5139                             imode_to_type(mode), tmp_err);
5140         err |= tmp_err;
5141         len = sizeof(*ref) + name_len;
5142         ref = (struct btrfs_inode_ref *)((char *)ref + len);
5143         cur += len;
5144         if (cur < total)
5145                 goto next;
5146
5147 out:
5148         *refs_ret = refs;
5149         return err;
5150 }
5151
5152 /*
5153  * Traverse the given INODE_EXTREF and call find_dir_item() to find related
5154  * DIR_ITEM/DIR_INDEX.
5155  *
5156  * @root:       the root of the fs/file tree
5157  * @ref_key:    the key of the INODE_EXTREF
5158  * @refs:       the count of INODE_EXTREF
5159  * @mode:       the st_mode of INODE_ITEM
5160  *
5161  * Return 0 if no error occurred.
5162  */
5163 static int check_inode_extref(struct btrfs_root *root,
5164                               struct btrfs_key *ref_key,
5165                               struct extent_buffer *node, int slot, u64 *refs,
5166                               int mode)
5167 {
5168         struct btrfs_key key;
5169         struct btrfs_key location;
5170         struct btrfs_inode_extref *extref;
5171         char namebuf[BTRFS_NAME_LEN] = {0};
5172         u32 total;
5173         u32 cur = 0;
5174         u32 len;
5175         u32 name_len;
5176         u64 index;
5177         u64 parent;
5178         int ret;
5179         int err = 0;
5180
5181         location.objectid = ref_key->objectid;
5182         location.type = BTRFS_INODE_ITEM_KEY;
5183         location.offset = 0;
5184
5185         extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
5186         total = btrfs_item_size_nr(node, slot);
5187
5188 next:
5189         /* update inode ref count */
5190         (*refs)++;
5191         name_len = btrfs_inode_extref_name_len(node, extref);
5192         index = btrfs_inode_extref_index(node, extref);
5193         parent = btrfs_inode_extref_parent(node, extref);
5194         if (name_len <= BTRFS_NAME_LEN) {
5195                 len = name_len;
5196         } else {
5197                 len = BTRFS_NAME_LEN;
5198                 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
5199                         root->objectid, ref_key->objectid, ref_key->offset);
5200         }
5201         read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
5202
5203         /* Check root dir ref name */
5204         if (index == 0 && strncmp(namebuf, "..", name_len)) {
5205                 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
5206                       root->objectid, ref_key->objectid, ref_key->offset,
5207                       namebuf);
5208                 err |= ROOT_DIR_ERROR;
5209         }
5210
5211         /* find related dir_index */
5212         key.objectid = parent;
5213         key.type = BTRFS_DIR_INDEX_KEY;
5214         key.offset = index;
5215         ret = find_dir_item(root, &key, &location, namebuf, len, mode);
5216         err |= ret;
5217
5218         /* find related dir_item */
5219         key.objectid = parent;
5220         key.type = BTRFS_DIR_ITEM_KEY;
5221         key.offset = btrfs_name_hash(namebuf, len);
5222         ret = find_dir_item(root, &key, &location, namebuf, len, mode);
5223         err |= ret;
5224
5225         len = sizeof(*extref) + name_len;
5226         extref = (struct btrfs_inode_extref *)((char *)extref + len);
5227         cur += len;
5228
5229         if (cur < total)
5230                 goto next;
5231
5232         return err;
5233 }
5234
5235 /*
5236  * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
5237  * DIR_ITEM/DIR_INDEX match.
5238  * Return with @index_ret.
5239  *
5240  * @root:       the root of the fs/file tree
5241  * @key:        the key of the INODE_REF/INODE_EXTREF
5242  * @name:       the name in the INODE_REF/INODE_EXTREF
5243  * @namelen:    the length of name in the INODE_REF/INODE_EXTREF
5244  * @index_ret:  the index in the INODE_REF/INODE_EXTREF,
5245  *              value (64)-1 means do not check index
5246  * @ext_ref:    the EXTENDED_IREF feature
5247  *
5248  * Return 0 if no error occurred.
5249  * Return >0 for error bitmap
5250  */
5251 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
5252                           char *name, int namelen, u64 *index_ret,
5253                           unsigned int ext_ref)
5254 {
5255         struct btrfs_path path;
5256         struct btrfs_inode_ref *ref;
5257         struct btrfs_inode_extref *extref;
5258         struct extent_buffer *node;
5259         char ref_namebuf[BTRFS_NAME_LEN] = {0};
5260         u32 total;
5261         u32 cur = 0;
5262         u32 len;
5263         u32 ref_namelen;
5264         u64 ref_index;
5265         u64 parent;
5266         u64 dir_id;
5267         int slot;
5268         int ret;
5269
5270         ASSERT(index_ret);
5271
5272         btrfs_init_path(&path);
5273         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
5274         if (ret) {
5275                 ret = INODE_REF_MISSING;
5276                 goto extref;
5277         }
5278
5279         node = path.nodes[0];
5280         slot = path.slots[0];
5281
5282         ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
5283         total = btrfs_item_size_nr(node, slot);
5284
5285         /* Iterate all entry of INODE_REF */
5286         while (cur < total) {
5287                 ret = INODE_REF_MISSING;
5288
5289                 ref_namelen = btrfs_inode_ref_name_len(node, ref);
5290                 ref_index = btrfs_inode_ref_index(node, ref);
5291                 if (*index_ret != (u64)-1 && *index_ret != ref_index)
5292                         goto next_ref;
5293
5294                 if (cur + sizeof(*ref) + ref_namelen > total ||
5295                     ref_namelen > BTRFS_NAME_LEN) {
5296                         warning("root %llu INODE %s[%llu %llu] name too long",
5297                                 root->objectid,
5298                                 key->type == BTRFS_INODE_REF_KEY ?
5299                                         "REF" : "EXTREF",
5300                                 key->objectid, key->offset);
5301
5302                         if (cur + sizeof(*ref) > total)
5303                                 break;
5304                         len = min_t(u32, total - cur - sizeof(*ref),
5305                                     BTRFS_NAME_LEN);
5306                 } else {
5307                         len = ref_namelen;
5308                 }
5309
5310                 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
5311                                    len);
5312
5313                 if (len != namelen || strncmp(ref_namebuf, name, len))
5314                         goto next_ref;
5315
5316                 *index_ret = ref_index;
5317                 ret = 0;
5318                 goto out;
5319 next_ref:
5320                 len = sizeof(*ref) + ref_namelen;
5321                 ref = (struct btrfs_inode_ref *)((char *)ref + len);
5322                 cur += len;
5323         }
5324
5325 extref:
5326         /* Skip if not support EXTENDED_IREF feature */
5327         if (!ext_ref)
5328                 goto out;
5329
5330         btrfs_release_path(&path);
5331         btrfs_init_path(&path);
5332
5333         dir_id = key->offset;
5334         key->type = BTRFS_INODE_EXTREF_KEY;
5335         key->offset = btrfs_extref_hash(dir_id, name, namelen);
5336
5337         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
5338         if (ret) {
5339                 ret = INODE_REF_MISSING;
5340                 goto out;
5341         }
5342
5343         node = path.nodes[0];
5344         slot = path.slots[0];
5345
5346         extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
5347         cur = 0;
5348         total = btrfs_item_size_nr(node, slot);
5349
5350         /* Iterate all entry of INODE_EXTREF */
5351         while (cur < total) {
5352                 ret = INODE_REF_MISSING;
5353
5354                 ref_namelen = btrfs_inode_extref_name_len(node, extref);
5355                 ref_index = btrfs_inode_extref_index(node, extref);
5356                 parent = btrfs_inode_extref_parent(node, extref);
5357                 if (*index_ret != (u64)-1 && *index_ret != ref_index)
5358                         goto next_extref;
5359
5360                 if (parent != dir_id)
5361                         goto next_extref;
5362
5363                 if (ref_namelen <= BTRFS_NAME_LEN) {
5364                         len = ref_namelen;
5365                 } else {
5366                         len = BTRFS_NAME_LEN;
5367                         warning("root %llu INODE %s[%llu %llu] name too long",
5368                                 root->objectid,
5369                                 key->type == BTRFS_INODE_REF_KEY ?
5370                                         "REF" : "EXTREF",
5371                                 key->objectid, key->offset);
5372                 }
5373                 read_extent_buffer(node, ref_namebuf,
5374                                    (unsigned long)(extref + 1), len);
5375
5376                 if (len != namelen || strncmp(ref_namebuf, name, len))
5377                         goto next_extref;
5378
5379                 *index_ret = ref_index;
5380                 ret = 0;
5381                 goto out;
5382
5383 next_extref:
5384                 len = sizeof(*extref) + ref_namelen;
5385                 extref = (struct btrfs_inode_extref *)((char *)extref + len);
5386                 cur += len;
5387
5388         }
5389 out:
5390         btrfs_release_path(&path);
5391         return ret;
5392 }
5393
5394 static void print_dir_item_err(struct btrfs_root *root, struct btrfs_key *key,
5395                                u64 ino, u64 index, const char *namebuf,
5396                                int name_len, u8 filetype, int err)
5397 {
5398         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING)) {
5399                 error("root %llu DIR ITEM[%llu %llu] name %s filetype %d %s",
5400                       root->objectid, key->objectid, key->offset, namebuf,
5401                       filetype,
5402                       err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
5403         }
5404
5405         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING)) {
5406                 error("root %llu DIR INDEX[%llu %llu] name %s filetype %d %s",
5407                       root->objectid, key->objectid, index, namebuf, filetype,
5408                       err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
5409         }
5410
5411         if (err & (INODE_ITEM_MISSING | INODE_ITEM_MISMATCH)) {
5412                 error(
5413                 "root %llu INODE_ITEM[%llu] index %llu name %s filetype %d %s",
5414                       root->objectid, ino, index, namebuf, filetype,
5415                       err & INODE_ITEM_MISMATCH ? "mismath" : "missing");
5416         }
5417
5418         if (err & INODE_REF_MISSING)
5419                 error(
5420                 "root %llu INODE REF[%llu, %llu] name %s filetype %u missing",
5421                       root->objectid, ino, key->objectid, namebuf, filetype);
5422
5423 }
5424
5425 /*
5426  * Call repair_inode_item_missing and repair_ternary_lowmem to repair
5427  *
5428  * Returns error after repair
5429  */
5430 static int repair_dir_item(struct btrfs_root *root, u64 dirid, u64 ino,
5431                            u64 index, u8 filetype, char *namebuf, u32 name_len,
5432                            int err)
5433 {
5434         int ret;
5435
5436         if (err & INODE_ITEM_MISSING) {
5437                 ret = repair_inode_item_missing(root, ino, filetype);
5438                 if (!ret)
5439                         err &= ~(INODE_ITEM_MISMATCH | INODE_ITEM_MISSING);
5440         }
5441
5442         if (err & ~(INODE_ITEM_MISMATCH | INODE_ITEM_MISSING)) {
5443                 ret = repair_ternary_lowmem(root, dirid, ino, index, namebuf,
5444                                             name_len, filetype, err);
5445                 if (!ret) {
5446                         err &= ~(DIR_INDEX_MISMATCH | DIR_INDEX_MISSING);
5447                         err &= ~(DIR_ITEM_MISMATCH | DIR_ITEM_MISSING);
5448                         err &= ~(INODE_REF_MISSING);
5449                 }
5450         }
5451         return err;
5452 }
5453
5454 static int __count_dir_isize(struct btrfs_root *root, u64 ino, int type,
5455                 u64 *size_ret)
5456 {
5457         struct btrfs_key key;
5458         struct btrfs_path path;
5459         u32 len;
5460         struct btrfs_dir_item *di;
5461         int ret;
5462         int cur = 0;
5463         int total = 0;
5464
5465         ASSERT(size_ret);
5466         *size_ret = 0;
5467
5468         key.objectid = ino;
5469         key.type = type;
5470         key.offset = (u64)-1;
5471
5472         btrfs_init_path(&path);
5473         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5474         if (ret < 0) {
5475                 ret = -EIO;
5476                 goto out;
5477         }
5478         /* if found, go to spacial case */
5479         if (ret == 0)
5480                 goto special_case;
5481
5482 loop:
5483         ret = btrfs_previous_item(root, &path, ino, type);
5484
5485         if (ret) {
5486                 ret = 0;
5487                 goto out;
5488         }
5489
5490 special_case:
5491         di = btrfs_item_ptr(path.nodes[0], path.slots[0], struct btrfs_dir_item);
5492         cur = 0;
5493         total = btrfs_item_size_nr(path.nodes[0], path.slots[0]);
5494
5495         while (cur < total) {
5496                 len = btrfs_dir_name_len(path.nodes[0], di);
5497                 if (len > BTRFS_NAME_LEN)
5498                         len = BTRFS_NAME_LEN;
5499                 *size_ret += len;
5500
5501                 len += btrfs_dir_data_len(path.nodes[0], di);
5502                 len += sizeof(*di);
5503                 di = (struct btrfs_dir_item *)((char *)di + len);
5504                 cur += len;
5505         }
5506         goto loop;
5507
5508 out:
5509         btrfs_release_path(&path);
5510         return ret;
5511 }
5512
5513 static int count_dir_isize(struct btrfs_root *root, u64 ino, u64 *size)
5514 {
5515         u64 item_size;
5516         u64 index_size;
5517         int ret;
5518
5519         ASSERT(size);
5520         ret = __count_dir_isize(root, ino, BTRFS_DIR_ITEM_KEY, &item_size);
5521         if (ret)
5522                 goto out;
5523
5524         ret = __count_dir_isize(root, ino, BTRFS_DIR_INDEX_KEY, &index_size);
5525         if (ret)
5526                 goto out;
5527
5528         *size = item_size + index_size;
5529
5530 out:
5531         if (ret)
5532                 error("failed to count root %llu INODE[%llu] root size",
5533                       root->objectid, ino);
5534         return ret;
5535 }
5536
5537 /*
5538  * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
5539  * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
5540  *
5541  * @root:       the root of the fs/file tree
5542  * @key:        the key of the INODE_REF/INODE_EXTREF
5543  * @path:       the path
5544  * @size:       the st_size of the INODE_ITEM
5545  * @ext_ref:    the EXTENDED_IREF feature
5546  *
5547  * Return 0 if no error occurred.
5548  * Return DIR_COUNT_AGAIN if the isize of the inode should be recalculated.
5549  */
5550 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *di_key,
5551                           struct btrfs_path *path, u64 *size,
5552                           unsigned int ext_ref)
5553 {
5554         struct btrfs_dir_item *di;
5555         struct btrfs_inode_item *ii;
5556         struct btrfs_key key;
5557         struct btrfs_key location;
5558         struct extent_buffer *node;
5559         int slot;
5560         char namebuf[BTRFS_NAME_LEN] = {0};
5561         u32 total;
5562         u32 cur = 0;
5563         u32 len;
5564         u32 name_len;
5565         u32 data_len;
5566         u8 filetype;
5567         u32 mode = 0;
5568         u64 index;
5569         int ret;
5570         int err;
5571         int tmp_err;
5572         int need_research = 0;
5573
5574         /*
5575          * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
5576          * ignore index check.
5577          */
5578         if (di_key->type == BTRFS_DIR_INDEX_KEY)
5579                 index = di_key->offset;
5580         else
5581                 index = (u64)-1;
5582 begin:
5583         err = 0;
5584         cur = 0;
5585
5586         /* since after repair, path and the dir item may be changed */
5587         if (need_research) {
5588                 need_research = 0;
5589                 err |= DIR_COUNT_AGAIN;
5590                 btrfs_release_path(path);
5591                 ret = btrfs_search_slot(NULL, root, di_key, path, 0, 0);
5592                 /* the item was deleted, let path point the last checked item */
5593                 if (ret > 0) {
5594                         if (path->slots[0] == 0)
5595                                 btrfs_prev_leaf(root, path);
5596                         else
5597                                 path->slots[0]--;
5598                 }
5599                 if (ret)
5600                         goto out;
5601         }
5602
5603         node = path->nodes[0];
5604         slot = path->slots[0];
5605
5606         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
5607         total = btrfs_item_size_nr(node, slot);
5608         memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
5609
5610         while (cur < total) {
5611                 data_len = btrfs_dir_data_len(node, di);
5612                 tmp_err = 0;
5613                 if (data_len)
5614                         error("root %llu %s[%llu %llu] data_len shouldn't be %u",
5615                               root->objectid,
5616               di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
5617                               di_key->objectid, di_key->offset, data_len);
5618
5619                 name_len = btrfs_dir_name_len(node, di);
5620                 if (name_len <= BTRFS_NAME_LEN) {
5621                         len = name_len;
5622                 } else {
5623                         len = BTRFS_NAME_LEN;
5624                         warning("root %llu %s[%llu %llu] name too long",
5625                                 root->objectid,
5626                 di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
5627                                 di_key->objectid, di_key->offset);
5628                 }
5629                 (*size) += name_len;
5630                 read_extent_buffer(node, namebuf, (unsigned long)(di + 1),
5631                                    len);
5632                 filetype = btrfs_dir_type(node, di);
5633
5634                 if (di_key->type == BTRFS_DIR_ITEM_KEY &&
5635                     di_key->offset != btrfs_name_hash(namebuf, len)) {
5636                         err |= -EIO;
5637                         error("root %llu DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
5638                         root->objectid, di_key->objectid, di_key->offset,
5639                         namebuf, len, filetype, di_key->offset,
5640                         btrfs_name_hash(namebuf, len));
5641                 }
5642
5643                 btrfs_dir_item_key_to_cpu(node, di, &location);
5644                 /* Ignore related ROOT_ITEM check */
5645                 if (location.type == BTRFS_ROOT_ITEM_KEY)
5646                         goto next;
5647
5648                 btrfs_release_path(path);
5649                 /* Check relative INODE_ITEM(existence/filetype) */
5650                 ret = btrfs_search_slot(NULL, root, &location, path, 0, 0);
5651                 if (ret) {
5652                         tmp_err |= INODE_ITEM_MISSING;
5653                         goto next;
5654                 }
5655
5656                 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
5657                                     struct btrfs_inode_item);
5658                 mode = btrfs_inode_mode(path->nodes[0], ii);
5659                 if (imode_to_type(mode) != filetype) {
5660                         tmp_err |= INODE_ITEM_MISMATCH;
5661                         goto next;
5662                 }
5663
5664                 /* Check relative INODE_REF/INODE_EXTREF */
5665                 key.objectid = location.objectid;
5666                 key.type = BTRFS_INODE_REF_KEY;
5667                 key.offset = di_key->objectid;
5668                 tmp_err |= find_inode_ref(root, &key, namebuf, len,
5669                                           &index, ext_ref);
5670
5671                 /* check relative INDEX/ITEM */
5672                 key.objectid = di_key->objectid;
5673                 if (key.type == BTRFS_DIR_ITEM_KEY) {
5674                         key.type = BTRFS_DIR_INDEX_KEY;
5675                         key.offset = index;
5676                 } else {
5677                         key.type = BTRFS_DIR_ITEM_KEY;
5678                         key.offset = btrfs_name_hash(namebuf, name_len);
5679                 }
5680
5681                 tmp_err |= find_dir_item(root, &key, &location, namebuf,
5682                                          name_len, filetype);
5683                 /* find_dir_item may find index */
5684                 if (key.type == BTRFS_DIR_INDEX_KEY)
5685                         index = key.offset;
5686 next:
5687
5688                 if (tmp_err && repair) {
5689                         ret = repair_dir_item(root, di_key->objectid,
5690                                               location.objectid, index,
5691                                               imode_to_type(mode), namebuf,
5692                                               name_len, tmp_err);
5693                         if (ret != tmp_err) {
5694                                 need_research = 1;
5695                                 goto begin;
5696                         }
5697                 }
5698                 btrfs_release_path(path);
5699                 print_dir_item_err(root, di_key, location.objectid, index,
5700                                    namebuf, name_len, filetype, tmp_err);
5701                 err |= tmp_err;
5702                 len = sizeof(*di) + name_len + data_len;
5703                 di = (struct btrfs_dir_item *)((char *)di + len);
5704                 cur += len;
5705
5706                 if (di_key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
5707                         error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
5708                               root->objectid, di_key->objectid,
5709                               di_key->offset);
5710                         break;
5711                 }
5712         }
5713 out:
5714         /* research path */
5715         btrfs_release_path(path);
5716         ret = btrfs_search_slot(NULL, root, di_key, path, 0, 0);
5717         if (ret)
5718                 err |= ret > 0 ? -ENOENT : ret;
5719         return err;
5720 }
5721
5722 /*
5723  * Wrapper function of btrfs_punch_hole.
5724  *
5725  * Returns 0 means success.
5726  * Returns not 0 means error.
5727  */
5728 static int punch_extent_hole(struct btrfs_root *root, u64 ino, u64 start,
5729                              u64 len)
5730 {
5731         struct btrfs_trans_handle *trans;
5732         int ret = 0;
5733
5734         trans = btrfs_start_transaction(root, 1);
5735         if (IS_ERR(trans))
5736                 return PTR_ERR(trans);
5737
5738         ret = btrfs_punch_hole(trans, root, ino, start, len);
5739         if (ret)
5740                 error("failed to add hole [%llu, %llu] in inode [%llu]",
5741                       start, len, ino);
5742         else
5743                 printf("Add a hole [%llu, %llu] in inode [%llu]\n", start, len,
5744                        ino);
5745
5746         btrfs_commit_transaction(trans, root);
5747         return ret;
5748 }
5749
5750 /*
5751  * Check file extent datasum/hole, update the size of the file extents,
5752  * check and update the last offset of the file extent.
5753  *
5754  * @root:       the root of fs/file tree.
5755  * @fkey:       the key of the file extent.
5756  * @nodatasum:  INODE_NODATASUM feature.
5757  * @size:       the sum of all EXTENT_DATA items size for this inode.
5758  * @end:        the offset of the last extent.
5759  *
5760  * Return 0 if no error occurred.
5761  */
5762 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
5763                              struct extent_buffer *node, int slot,
5764                              unsigned int nodatasum, u64 *size, u64 *end)
5765 {
5766         struct btrfs_file_extent_item *fi;
5767         u64 disk_bytenr;
5768         u64 disk_num_bytes;
5769         u64 extent_num_bytes;
5770         u64 extent_offset;
5771         u64 csum_found;         /* In byte size, sectorsize aligned */
5772         u64 search_start;       /* Logical range start we search for csum */
5773         u64 search_len;         /* Logical range len we search for csum */
5774         unsigned int extent_type;
5775         unsigned int is_hole;
5776         int compressed = 0;
5777         int ret;
5778         int err = 0;
5779
5780         fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
5781
5782         /* Check inline extent */
5783         extent_type = btrfs_file_extent_type(node, fi);
5784         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
5785                 struct btrfs_item *e = btrfs_item_nr(slot);
5786                 u32 item_inline_len;
5787
5788                 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
5789                 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
5790                 compressed = btrfs_file_extent_compression(node, fi);
5791                 if (extent_num_bytes == 0) {
5792                         error(
5793                 "root %llu EXTENT_DATA[%llu %llu] has empty inline extent",
5794                                 root->objectid, fkey->objectid, fkey->offset);
5795                         err |= FILE_EXTENT_ERROR;
5796                 }
5797                 if (!compressed && extent_num_bytes != item_inline_len) {
5798                         error(
5799                 "root %llu EXTENT_DATA[%llu %llu] wrong inline size, have: %llu, expected: %u",
5800                                 root->objectid, fkey->objectid, fkey->offset,
5801                                 extent_num_bytes, item_inline_len);
5802                         err |= FILE_EXTENT_ERROR;
5803                 }
5804                 *end += extent_num_bytes;
5805                 *size += extent_num_bytes;
5806                 return err;
5807         }
5808
5809         /* Check extent type */
5810         if (extent_type != BTRFS_FILE_EXTENT_REG &&
5811                         extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
5812                 err |= FILE_EXTENT_ERROR;
5813                 error("root %llu EXTENT_DATA[%llu %llu] type bad",
5814                       root->objectid, fkey->objectid, fkey->offset);
5815                 return err;
5816         }
5817
5818         /* Check REG_EXTENT/PREALLOC_EXTENT */
5819         disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
5820         disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
5821         extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
5822         extent_offset = btrfs_file_extent_offset(node, fi);
5823         compressed = btrfs_file_extent_compression(node, fi);
5824         is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
5825
5826         /*
5827          * Check EXTENT_DATA csum
5828          *
5829          * For plain (uncompressed) extent, we should only check the range
5830          * we're referring to, as it's possible that part of prealloc extent
5831          * has been written, and has csum:
5832          *
5833          * |<--- Original large preallocated extent A ---->|
5834          * |<- Prealloc File Extent ->|<- Regular Extent ->|
5835          *      No csum                         Has csum
5836          *
5837          * For compressed extent, we should check the whole range.
5838          */
5839         if (!compressed) {
5840                 search_start = disk_bytenr + extent_offset;
5841                 search_len = extent_num_bytes;
5842         } else {
5843                 search_start = disk_bytenr;
5844                 search_len = disk_num_bytes;
5845         }
5846         ret = count_csum_range(root, search_start, search_len, &csum_found);
5847         if (csum_found > 0 && nodatasum) {
5848                 err |= ODD_CSUM_ITEM;
5849                 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
5850                       root->objectid, fkey->objectid, fkey->offset);
5851         } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
5852                    !is_hole && (ret < 0 || csum_found < search_len)) {
5853                 err |= CSUM_ITEM_MISSING;
5854                 error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
5855                       root->objectid, fkey->objectid, fkey->offset,
5856                       csum_found, search_len);
5857         } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
5858                 err |= ODD_CSUM_ITEM;
5859                 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
5860                       root->objectid, fkey->objectid, fkey->offset, csum_found);
5861         }
5862
5863         /* Check EXTENT_DATA hole */
5864         if (!no_holes && *end != fkey->offset) {
5865                 if (repair)
5866                         ret = punch_extent_hole(root, fkey->objectid,
5867                                                 *end, fkey->offset - *end);
5868                 if (!repair || ret) {
5869                         err |= FILE_EXTENT_ERROR;
5870                         error("root %llu EXTENT_DATA[%llu %llu] interrupt",
5871                               root->objectid, fkey->objectid, fkey->offset);
5872                 }
5873         }
5874
5875         *end += extent_num_bytes;
5876         if (!is_hole)
5877                 *size += extent_num_bytes;
5878
5879         return err;
5880 }
5881
5882 /*
5883  * Set inode item nbytes to @nbytes
5884  *
5885  * Returns  0     on success
5886  * Returns  != 0  on error
5887  */
5888 static int repair_inode_nbytes_lowmem(struct btrfs_root *root,
5889                                       struct btrfs_path *path,
5890                                       u64 ino, u64 nbytes)
5891 {
5892         struct btrfs_trans_handle *trans;
5893         struct btrfs_inode_item *ii;
5894         struct btrfs_key key;
5895         struct btrfs_key research_key;
5896         int err = 0;
5897         int ret;
5898
5899         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
5900
5901         key.objectid = ino;
5902         key.type = BTRFS_INODE_ITEM_KEY;
5903         key.offset = 0;
5904
5905         trans = btrfs_start_transaction(root, 1);
5906         if (IS_ERR(trans)) {
5907                 ret = PTR_ERR(trans);
5908                 err |= ret;
5909                 goto out;
5910         }
5911
5912         btrfs_release_path(path);
5913         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
5914         if (ret > 0)
5915                 ret = -ENOENT;
5916         if (ret) {
5917                 err |= ret;
5918                 goto fail;
5919         }
5920
5921         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
5922                             struct btrfs_inode_item);
5923         btrfs_set_inode_nbytes(path->nodes[0], ii, nbytes);
5924         btrfs_mark_buffer_dirty(path->nodes[0]);
5925 fail:
5926         btrfs_commit_transaction(trans, root);
5927 out:
5928         if (ret)
5929                 error("failed to set nbytes in inode %llu root %llu",
5930                       ino, root->root_key.objectid);
5931         else
5932                 printf("Set nbytes in inode item %llu root %llu\n to %llu", ino,
5933                        root->root_key.objectid, nbytes);
5934
5935         /* research path */
5936         btrfs_release_path(path);
5937         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
5938         err |= ret;
5939
5940         return err;
5941 }
5942
5943 /*
5944  * Set directory inode isize to @isize.
5945  *
5946  * Returns 0     on success.
5947  * Returns != 0  on error.
5948  */
5949 static int repair_dir_isize_lowmem(struct btrfs_root *root,
5950                                    struct btrfs_path *path,
5951                                    u64 ino, u64 isize)
5952 {
5953         struct btrfs_trans_handle *trans;
5954         struct btrfs_inode_item *ii;
5955         struct btrfs_key key;
5956         struct btrfs_key research_key;
5957         int ret;
5958         int err = 0;
5959
5960         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
5961
5962         key.objectid = ino;
5963         key.type = BTRFS_INODE_ITEM_KEY;
5964         key.offset = 0;
5965
5966         trans = btrfs_start_transaction(root, 1);
5967         if (IS_ERR(trans)) {
5968                 ret = PTR_ERR(trans);
5969                 err |= ret;
5970                 goto out;
5971         }
5972
5973         btrfs_release_path(path);
5974         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
5975         if (ret > 0)
5976                 ret = -ENOENT;
5977         if (ret) {
5978                 err |= ret;
5979                 goto fail;
5980         }
5981
5982         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
5983                             struct btrfs_inode_item);
5984         btrfs_set_inode_size(path->nodes[0], ii, isize);
5985         btrfs_mark_buffer_dirty(path->nodes[0]);
5986 fail:
5987         btrfs_commit_transaction(trans, root);
5988 out:
5989         if (ret)
5990                 error("failed to set isize in inode %llu root %llu",
5991                       ino, root->root_key.objectid);
5992         else
5993                 printf("Set isize in inode %llu root %llu to %llu\n",
5994                        ino, root->root_key.objectid, isize);
5995
5996         btrfs_release_path(path);
5997         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
5998         err |= ret;
5999
6000         return err;
6001 }
6002
6003 /*
6004  * Wrapper function for btrfs_add_orphan_item().
6005  *
6006  * Returns 0     on success.
6007  * Returns != 0  on error.
6008  */
6009 static int repair_inode_orphan_item_lowmem(struct btrfs_root *root,
6010                                            struct btrfs_path *path, u64 ino)
6011 {
6012         struct btrfs_trans_handle *trans;
6013         struct btrfs_key research_key;
6014         int ret;
6015         int err = 0;
6016
6017         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
6018
6019         trans = btrfs_start_transaction(root, 1);
6020         if (IS_ERR(trans)) {
6021                 ret = PTR_ERR(trans);
6022                 err |= ret;
6023                 goto out;
6024         }
6025
6026         btrfs_release_path(path);
6027         ret = btrfs_add_orphan_item(trans, root, path, ino);
6028         err |= ret;
6029         btrfs_commit_transaction(trans, root);
6030 out:
6031         if (ret)
6032                 error("failed to add inode %llu as orphan item root %llu",
6033                       ino, root->root_key.objectid);
6034         else
6035                 printf("Added inode %llu as orphan item root %llu\n",
6036                        ino, root->root_key.objectid);
6037
6038         btrfs_release_path(path);
6039         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
6040         err |= ret;
6041
6042         return err;
6043 }
6044
6045 /* Set inode_item nlink to @ref_count.
6046  * If @ref_count == 0, move it to "lost+found" and increase @ref_count.
6047  *
6048  * Returns 0 on success
6049  */
6050 static int repair_inode_nlinks_lowmem(struct btrfs_root *root,
6051                                       struct btrfs_path *path, u64 ino,
6052                                       const char *name, u32 namelen,
6053                                       u64 ref_count, u8 filetype, u64 *nlink)
6054 {
6055         struct btrfs_trans_handle *trans;
6056         struct btrfs_inode_item *ii;
6057         struct btrfs_key key;
6058         struct btrfs_key old_key;
6059         char namebuf[BTRFS_NAME_LEN] = {0};
6060         int name_len;
6061         int ret;
6062         int ret2;
6063
6064         /* save the key */
6065         btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]);
6066
6067         if (name && namelen) {
6068                 ASSERT(namelen <= BTRFS_NAME_LEN);
6069                 memcpy(namebuf, name, namelen);
6070                 name_len = namelen;
6071         } else {
6072                 sprintf(namebuf, "%llu", ino);
6073                 name_len = count_digits(ino);
6074                 printf("Can't find file name for inode %llu, use %s instead\n",
6075                        ino, namebuf);
6076         }
6077
6078         trans = btrfs_start_transaction(root, 1);
6079         if (IS_ERR(trans)) {
6080                 ret = PTR_ERR(trans);
6081                 goto out;
6082         }
6083
6084         btrfs_release_path(path);
6085         /* if refs is 0, put it into lostfound */
6086         if (ref_count == 0) {
6087                 ret = link_inode_to_lostfound(trans, root, path, ino, namebuf,
6088                                               name_len, filetype, &ref_count);
6089                 if (ret)
6090                         goto fail;
6091         }
6092
6093         /* reset inode_item's nlink to ref_count */
6094         key.objectid = ino;
6095         key.type = BTRFS_INODE_ITEM_KEY;
6096         key.offset = 0;
6097
6098         btrfs_release_path(path);
6099         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
6100         if (ret > 0)
6101                 ret = -ENOENT;
6102         if (ret)
6103                 goto fail;
6104
6105         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
6106                             struct btrfs_inode_item);
6107         btrfs_set_inode_nlink(path->nodes[0], ii, ref_count);
6108         btrfs_mark_buffer_dirty(path->nodes[0]);
6109
6110         if (nlink)
6111                 *nlink = ref_count;
6112 fail:
6113         btrfs_commit_transaction(trans, root);
6114 out:
6115         if (ret)
6116                 error(
6117         "fail to repair nlink of inode %llu root %llu name %s filetype %u",
6118                        root->objectid, ino, namebuf, filetype);
6119         else
6120                 printf("Fixed nlink of inode %llu root %llu name %s filetype %u\n",
6121                        root->objectid, ino, namebuf, filetype);
6122
6123         /* research */
6124         btrfs_release_path(path);
6125         ret2 = btrfs_search_slot(NULL, root, &old_key, path, 0, 0);
6126         if (ret2 < 0)
6127                 return ret |= ret2;
6128         return ret;
6129 }
6130
6131 /*
6132  * Check INODE_ITEM and related ITEMs (the same inode number)
6133  * 1. check link count
6134  * 2. check inode ref/extref
6135  * 3. check dir item/index
6136  *
6137  * @ext_ref:    the EXTENDED_IREF feature
6138  *
6139  * Return 0 if no error occurred.
6140  * Return >0 for error or hit the traversal is done(by error bitmap)
6141  */
6142 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
6143                             unsigned int ext_ref)
6144 {
6145         struct extent_buffer *node;
6146         struct btrfs_inode_item *ii;
6147         struct btrfs_key key;
6148         struct btrfs_key last_key;
6149         u64 inode_id;
6150         u32 mode;
6151         u64 nlink;
6152         u64 nbytes;
6153         u64 isize;
6154         u64 size = 0;
6155         u64 refs = 0;
6156         u64 extent_end = 0;
6157         u64 extent_size = 0;
6158         unsigned int dir;
6159         unsigned int nodatasum;
6160         int slot;
6161         int ret;
6162         int err = 0;
6163         char namebuf[BTRFS_NAME_LEN] = {0};
6164         u32 name_len = 0;
6165
6166         node = path->nodes[0];
6167         slot = path->slots[0];
6168
6169         btrfs_item_key_to_cpu(node, &key, slot);
6170         inode_id = key.objectid;
6171
6172         if (inode_id == BTRFS_ORPHAN_OBJECTID) {
6173                 ret = btrfs_next_item(root, path);
6174                 if (ret > 0)
6175                         err |= LAST_ITEM;
6176                 return err;
6177         }
6178
6179         ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
6180         isize = btrfs_inode_size(node, ii);
6181         nbytes = btrfs_inode_nbytes(node, ii);
6182         mode = btrfs_inode_mode(node, ii);
6183         dir = imode_to_type(mode) == BTRFS_FT_DIR;
6184         nlink = btrfs_inode_nlink(node, ii);
6185         nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
6186
6187         while (1) {
6188                 btrfs_item_key_to_cpu(path->nodes[0], &last_key, path->slots[0]);
6189                 ret = btrfs_next_item(root, path);
6190                 if (ret < 0) {
6191                         /* out will fill 'err' rusing current statistics */
6192                         goto out;
6193                 } else if (ret > 0) {
6194                         err |= LAST_ITEM;
6195                         goto out;
6196                 }
6197
6198                 node = path->nodes[0];
6199                 slot = path->slots[0];
6200                 btrfs_item_key_to_cpu(node, &key, slot);
6201                 if (key.objectid != inode_id)
6202                         goto out;
6203
6204                 switch (key.type) {
6205                 case BTRFS_INODE_REF_KEY:
6206                         ret = check_inode_ref(root, &key, path, namebuf,
6207                                               &name_len, &refs, mode);
6208                         err |= ret;
6209                         break;
6210                 case BTRFS_INODE_EXTREF_KEY:
6211                         if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
6212                                 warning("root %llu EXTREF[%llu %llu] isn't supported",
6213                                         root->objectid, key.objectid,
6214                                         key.offset);
6215                         ret = check_inode_extref(root, &key, node, slot, &refs,
6216                                                  mode);
6217                         err |= ret;
6218                         break;
6219                 case BTRFS_DIR_ITEM_KEY:
6220                 case BTRFS_DIR_INDEX_KEY:
6221                         if (!dir) {
6222                                 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
6223                                         root->objectid, inode_id,
6224                                         imode_to_type(mode), key.objectid,
6225                                         key.offset);
6226                         }
6227                         ret = check_dir_item(root, &key, path, &size, ext_ref);
6228                         err |= ret;
6229                         break;
6230                 case BTRFS_EXTENT_DATA_KEY:
6231                         if (dir) {
6232                                 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
6233                                         root->objectid, inode_id, key.objectid,
6234                                         key.offset);
6235                         }
6236                         ret = check_file_extent(root, &key, node, slot,
6237                                                 nodatasum, &extent_size,
6238                                                 &extent_end);
6239                         err |= ret;
6240                         break;
6241                 case BTRFS_XATTR_ITEM_KEY:
6242                         break;
6243                 default:
6244                         error("ITEM[%llu %u %llu] UNKNOWN TYPE",
6245                               key.objectid, key.type, key.offset);
6246                 }
6247         }
6248
6249 out:
6250         if (err & LAST_ITEM) {
6251                 btrfs_release_path(path);
6252                 ret = btrfs_search_slot(NULL, root, &last_key, path, 0, 0);
6253                 if (ret)
6254                         return err;
6255         }
6256
6257         /* verify INODE_ITEM nlink/isize/nbytes */
6258         if (dir) {
6259                 if (repair && (err & DIR_COUNT_AGAIN)) {
6260                         err &= ~DIR_COUNT_AGAIN;
6261                         count_dir_isize(root, inode_id, &size);
6262                 }
6263
6264                 if ((nlink != 1 || refs != 1) && repair) {
6265                         ret = repair_inode_nlinks_lowmem(root, path, inode_id,
6266                                 namebuf, name_len, refs, imode_to_type(mode),
6267                                 &nlink);
6268                 }
6269
6270                 if (nlink != 1) {
6271                         err |= LINK_COUNT_ERROR;
6272                         error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
6273                               root->objectid, inode_id, nlink);
6274                 }
6275
6276                 /*
6277                  * Just a warning, as dir inode nbytes is just an
6278                  * instructive value.
6279                  */
6280                 if (!IS_ALIGNED(nbytes, root->fs_info->nodesize)) {
6281                         warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
6282                                 root->objectid, inode_id,
6283                                 root->fs_info->nodesize);
6284                 }
6285
6286                 if (isize != size) {
6287                         if (repair)
6288                                 ret = repair_dir_isize_lowmem(root, path,
6289                                                               inode_id, size);
6290                         if (!repair || ret) {
6291                                 err |= ISIZE_ERROR;
6292                                 error(
6293                 "root %llu DIR INODE [%llu] size %llu not equal to %llu",
6294                                       root->objectid, inode_id, isize, size);
6295                         }
6296                 }
6297         } else {
6298                 if (nlink != refs) {
6299                         if (repair)
6300                                 ret = repair_inode_nlinks_lowmem(root, path,
6301                                          inode_id, namebuf, name_len, refs,
6302                                          imode_to_type(mode), &nlink);
6303                         if (!repair || ret) {
6304                                 err |= LINK_COUNT_ERROR;
6305                                 error(
6306                 "root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
6307                                       root->objectid, inode_id, nlink, refs);
6308                         }
6309                 } else if (!nlink) {
6310                         if (repair)
6311                                 ret = repair_inode_orphan_item_lowmem(root,
6312                                                               path, inode_id);
6313                         if (!repair || ret) {
6314                                 err |= ORPHAN_ITEM;
6315                                 error("root %llu INODE[%llu] is orphan item",
6316                                       root->objectid, inode_id);
6317                         }
6318                 }
6319
6320                 if (!nbytes && !no_holes && extent_end < isize) {
6321                         if (repair)
6322                                 ret = punch_extent_hole(root, inode_id,
6323                                                 extent_end, isize - extent_end);
6324                         if (!repair || ret) {
6325                                 err |= NBYTES_ERROR;
6326                                 error(
6327         "root %llu INODE[%llu] size %llu should have a file extent hole",
6328                                       root->objectid, inode_id, isize);
6329                         }
6330                 }
6331
6332                 if (nbytes != extent_size) {
6333                         if (repair)
6334                                 ret = repair_inode_nbytes_lowmem(root, path,
6335                                                          inode_id, extent_size);
6336                         if (!repair || ret) {
6337                                 err |= NBYTES_ERROR;
6338                                 error(
6339         "root %llu INODE[%llu] nbytes %llu not equal to extent_size %llu",
6340                                       root->objectid, inode_id, nbytes,
6341                                       extent_size);
6342                         }
6343                 }
6344         }
6345
6346         if (err & LAST_ITEM)
6347                 btrfs_next_item(root, path);
6348         return err;
6349 }
6350
6351 /*
6352  * Insert the missing inode item and inode ref.
6353  *
6354  * Normal INODE_ITEM_MISSING and INODE_REF_MISSING are handled in backref * dir.
6355  * Root dir should be handled specially because root dir is the root of fs.
6356  *
6357  * returns err (>0 or 0) after repair
6358  */
6359 static int repair_fs_first_inode(struct btrfs_root *root, int err)
6360 {
6361         struct btrfs_trans_handle *trans;
6362         struct btrfs_key key;
6363         struct btrfs_path path;
6364         int filetype = BTRFS_FT_DIR;
6365         int ret = 0;
6366
6367         btrfs_init_path(&path);
6368
6369         if (err & INODE_REF_MISSING) {
6370                 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
6371                 key.type = BTRFS_INODE_REF_KEY;
6372                 key.offset = BTRFS_FIRST_FREE_OBJECTID;
6373
6374                 trans = btrfs_start_transaction(root, 1);
6375                 if (IS_ERR(trans)) {
6376                         ret = PTR_ERR(trans);
6377                         goto out;
6378                 }
6379
6380                 btrfs_release_path(&path);
6381                 ret = btrfs_search_slot(trans, root, &key, &path, 1, 1);
6382                 if (ret)
6383                         goto trans_fail;
6384
6385                 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
6386                                              BTRFS_FIRST_FREE_OBJECTID,
6387                                              BTRFS_FIRST_FREE_OBJECTID, 0);
6388                 if (ret)
6389                         goto trans_fail;
6390
6391                 printf("Add INODE_REF[%llu %llu] name %s\n",
6392                        BTRFS_FIRST_FREE_OBJECTID, BTRFS_FIRST_FREE_OBJECTID,
6393                        "..");
6394                 err &= ~INODE_REF_MISSING;
6395 trans_fail:
6396                 if (ret)
6397                         error("fail to insert first inode's ref");
6398                 btrfs_commit_transaction(trans, root);
6399         }
6400
6401         if (err & INODE_ITEM_MISSING) {
6402                 ret = repair_inode_item_missing(root,
6403                                         BTRFS_FIRST_FREE_OBJECTID, filetype);
6404                 if (ret)
6405                         goto out;
6406                 err &= ~INODE_ITEM_MISSING;
6407         }
6408 out:
6409         if (ret)
6410                 error("fail to repair first inode");
6411         btrfs_release_path(&path);
6412         return err;
6413 }
6414
6415 /*
6416  * check first root dir's inode_item and inode_ref
6417  *
6418  * returns 0 means no error
6419  * returns >0 means error
6420  * returns <0 means fatal error
6421  */
6422 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
6423 {
6424         struct btrfs_path path;
6425         struct btrfs_key key;
6426         struct btrfs_inode_item *ii;
6427         u64 index;
6428         u32 mode;
6429         int err = 0;
6430         int ret;
6431
6432         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
6433         key.type = BTRFS_INODE_ITEM_KEY;
6434         key.offset = 0;
6435
6436         /* For root being dropped, we don't need to check first inode */
6437         if (btrfs_root_refs(&root->root_item) == 0 &&
6438             btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
6439             BTRFS_FIRST_FREE_OBJECTID)
6440                 return 0;
6441
6442         btrfs_init_path(&path);
6443         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6444         if (ret < 0)
6445                 goto out;
6446         if (ret > 0) {
6447                 ret = 0;
6448                 err |= INODE_ITEM_MISSING;
6449         } else {
6450                 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
6451                                     struct btrfs_inode_item);
6452                 mode = btrfs_inode_mode(path.nodes[0], ii);
6453                 if (imode_to_type(mode) != BTRFS_FT_DIR)
6454                         err |= INODE_ITEM_MISMATCH;
6455         }
6456
6457         /* lookup first inode ref */
6458         key.offset = BTRFS_FIRST_FREE_OBJECTID;
6459         key.type = BTRFS_INODE_REF_KEY;
6460         /* special index value */
6461         index = 0;
6462
6463         ret = find_inode_ref(root, &key, "..", strlen(".."), &index, ext_ref);
6464         if (ret < 0)
6465                 goto out;
6466         err |= ret;
6467
6468 out:
6469         btrfs_release_path(&path);
6470
6471         if (err && repair)
6472                 err = repair_fs_first_inode(root, err);
6473
6474         if (err & (INODE_ITEM_MISSING | INODE_ITEM_MISMATCH))
6475                 error("root dir INODE_ITEM is %s",
6476                       err & INODE_ITEM_MISMATCH ? "mismatch" : "missing");
6477         if (err & INODE_REF_MISSING)
6478                 error("root dir INODE_REF is missing");
6479
6480         return ret < 0 ? ret : err;
6481 }
6482
6483 static struct tree_backref *find_tree_backref(struct extent_record *rec,
6484                                                 u64 parent, u64 root)
6485 {
6486         struct rb_node *node;
6487         struct tree_backref *back = NULL;
6488         struct tree_backref match = {
6489                 .node = {
6490                         .is_data = 0,
6491                 },
6492         };
6493
6494         if (parent) {
6495                 match.parent = parent;
6496                 match.node.full_backref = 1;
6497         } else {
6498                 match.root = root;
6499         }
6500
6501         node = rb_search(&rec->backref_tree, &match.node.node,
6502                          (rb_compare_keys)compare_extent_backref, NULL);
6503         if (node)
6504                 back = to_tree_backref(rb_node_to_extent_backref(node));
6505
6506         return back;
6507 }
6508
6509 static struct data_backref *find_data_backref(struct extent_record *rec,
6510                                                 u64 parent, u64 root,
6511                                                 u64 owner, u64 offset,
6512                                                 int found_ref,
6513                                                 u64 disk_bytenr, u64 bytes)
6514 {
6515         struct rb_node *node;
6516         struct data_backref *back = NULL;
6517         struct data_backref match = {
6518                 .node = {
6519                         .is_data = 1,
6520                 },
6521                 .owner = owner,
6522                 .offset = offset,
6523                 .bytes = bytes,
6524                 .found_ref = found_ref,
6525                 .disk_bytenr = disk_bytenr,
6526         };
6527
6528         if (parent) {
6529                 match.parent = parent;
6530                 match.node.full_backref = 1;
6531         } else {
6532                 match.root = root;
6533         }
6534
6535         node = rb_search(&rec->backref_tree, &match.node.node,
6536                          (rb_compare_keys)compare_extent_backref, NULL);
6537         if (node)
6538                 back = to_data_backref(rb_node_to_extent_backref(node));
6539
6540         return back;
6541 }
6542 /*
6543  * This function calls walk_down_tree_v2 and walk_up_tree_v2 to check tree
6544  * blocks and integrity of fs tree items.
6545  *
6546  * @root:         the root of the tree to be checked.
6547  * @ext_ref       feature EXTENDED_IREF is enable or not.
6548  * @account       if NOT 0 means check the tree (including tree)'s treeblocks.
6549  *                otherwise means check fs tree(s) items relationship and
6550  *                @root MUST be a fs tree root.
6551  * Returns 0      represents OK.
6552  * Returns not 0  represents error.
6553  */
6554 static int check_btrfs_root(struct btrfs_trans_handle *trans,
6555                             struct btrfs_root *root, unsigned int ext_ref,
6556                             int check_all)
6557
6558 {
6559         struct btrfs_path path;
6560         struct node_refs nrefs;
6561         struct btrfs_root_item *root_item = &root->root_item;
6562         int ret;
6563         int level;
6564         int err = 0;
6565
6566         memset(&nrefs, 0, sizeof(nrefs));
6567         if (!check_all) {
6568                 /*
6569                  * We need to manually check the first inode item (256)
6570                  * As the following traversal function will only start from
6571                  * the first inode item in the leaf, if inode item (256) is
6572                  * missing we will skip it forever.
6573                  */
6574                 ret = check_fs_first_inode(root, ext_ref);
6575                 if (ret < 0)
6576                         return ret;
6577         }
6578
6579
6580         level = btrfs_header_level(root->node);
6581         btrfs_init_path(&path);
6582
6583         if (btrfs_root_refs(root_item) > 0 ||
6584             btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
6585                 path.nodes[level] = root->node;
6586                 path.slots[level] = 0;
6587                 extent_buffer_get(root->node);
6588         } else {
6589                 struct btrfs_key key;
6590
6591                 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
6592                 level = root_item->drop_level;
6593                 path.lowest_level = level;
6594                 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6595                 if (ret < 0)
6596                         goto out;
6597                 ret = 0;
6598         }
6599
6600         while (1) {
6601                 ret = walk_down_tree_v2(trans, root, &path, &level, &nrefs,
6602                                         ext_ref, check_all);
6603
6604                 err |= !!ret;
6605
6606                 /* if ret is negative, walk shall stop */
6607                 if (ret < 0) {
6608                         ret = err;
6609                         break;
6610                 }
6611
6612                 ret = walk_up_tree_v2(root, &path, &level);
6613                 if (ret != 0) {
6614                         /* Normal exit, reset ret to err */
6615                         ret = err;
6616                         break;
6617                 }
6618         }
6619
6620 out:
6621         btrfs_release_path(&path);
6622         return ret;
6623 }
6624
6625 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info);
6626
6627 /*
6628  * Iterate all items in the tree and call check_inode_item() to check.
6629  *
6630  * @root:       the root of the tree to be checked.
6631  * @ext_ref:    the EXTENDED_IREF feature
6632  *
6633  * Return 0 if no error found.
6634  * Return <0 for error.
6635  */
6636 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
6637 {
6638         reset_cached_block_groups(root->fs_info);
6639         return check_btrfs_root(NULL, root, ext_ref, 0);
6640 }
6641
6642 /*
6643  * Find the relative ref for root_ref and root_backref.
6644  *
6645  * @root:       the root of the root tree.
6646  * @ref_key:    the key of the root ref.
6647  *
6648  * Return 0 if no error occurred.
6649  */
6650 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
6651                           struct extent_buffer *node, int slot)
6652 {
6653         struct btrfs_path path;
6654         struct btrfs_key key;
6655         struct btrfs_root_ref *ref;
6656         struct btrfs_root_ref *backref;
6657         char ref_name[BTRFS_NAME_LEN] = {0};
6658         char backref_name[BTRFS_NAME_LEN] = {0};
6659         u64 ref_dirid;
6660         u64 ref_seq;
6661         u32 ref_namelen;
6662         u64 backref_dirid;
6663         u64 backref_seq;
6664         u32 backref_namelen;
6665         u32 len;
6666         int ret;
6667         int err = 0;
6668
6669         ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
6670         ref_dirid = btrfs_root_ref_dirid(node, ref);
6671         ref_seq = btrfs_root_ref_sequence(node, ref);
6672         ref_namelen = btrfs_root_ref_name_len(node, ref);
6673
6674         if (ref_namelen <= BTRFS_NAME_LEN) {
6675                 len = ref_namelen;
6676         } else {
6677                 len = BTRFS_NAME_LEN;
6678                 warning("%s[%llu %llu] ref_name too long",
6679                         ref_key->type == BTRFS_ROOT_REF_KEY ?
6680                         "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
6681                         ref_key->offset);
6682         }
6683         read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
6684
6685         /* Find relative root_ref */
6686         key.objectid = ref_key->offset;
6687         key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
6688         key.offset = ref_key->objectid;
6689
6690         btrfs_init_path(&path);
6691         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
6692         if (ret) {
6693                 err |= ROOT_REF_MISSING;
6694                 error("%s[%llu %llu] couldn't find relative ref",
6695                       ref_key->type == BTRFS_ROOT_REF_KEY ?
6696                       "ROOT_REF" : "ROOT_BACKREF",
6697                       ref_key->objectid, ref_key->offset);
6698                 goto out;
6699         }
6700
6701         backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
6702                                  struct btrfs_root_ref);
6703         backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
6704         backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
6705         backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
6706
6707         if (backref_namelen <= BTRFS_NAME_LEN) {
6708                 len = backref_namelen;
6709         } else {
6710                 len = BTRFS_NAME_LEN;
6711                 warning("%s[%llu %llu] ref_name too long",
6712                         key.type == BTRFS_ROOT_REF_KEY ?
6713                         "ROOT_REF" : "ROOT_BACKREF",
6714                         key.objectid, key.offset);
6715         }
6716         read_extent_buffer(path.nodes[0], backref_name,
6717                            (unsigned long)(backref + 1), len);
6718
6719         if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
6720             ref_namelen != backref_namelen ||
6721             strncmp(ref_name, backref_name, len)) {
6722                 err |= ROOT_REF_MISMATCH;
6723                 error("%s[%llu %llu] mismatch relative ref",
6724                       ref_key->type == BTRFS_ROOT_REF_KEY ?
6725                       "ROOT_REF" : "ROOT_BACKREF",
6726                       ref_key->objectid, ref_key->offset);
6727         }
6728 out:
6729         btrfs_release_path(&path);
6730         return err;
6731 }
6732
6733 /*
6734  * Check all fs/file tree in low_memory mode.
6735  *
6736  * 1. for fs tree root item, call check_fs_root_v2()
6737  * 2. for fs tree root ref/backref, call check_root_ref()
6738  *
6739  * Return 0 if no error occurred.
6740  */
6741 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
6742 {
6743         struct btrfs_root *tree_root = fs_info->tree_root;
6744         struct btrfs_root *cur_root = NULL;
6745         struct btrfs_path path;
6746         struct btrfs_key key;
6747         struct extent_buffer *node;
6748         unsigned int ext_ref;
6749         int slot;
6750         int ret;
6751         int err = 0;
6752
6753         ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
6754
6755         btrfs_init_path(&path);
6756         key.objectid = BTRFS_FS_TREE_OBJECTID;
6757         key.offset = 0;
6758         key.type = BTRFS_ROOT_ITEM_KEY;
6759
6760         ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
6761         if (ret < 0) {
6762                 err = ret;
6763                 goto out;
6764         } else if (ret > 0) {
6765                 err = -ENOENT;
6766                 goto out;
6767         }
6768
6769         while (1) {
6770                 node = path.nodes[0];
6771                 slot = path.slots[0];
6772                 btrfs_item_key_to_cpu(node, &key, slot);
6773                 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
6774                         goto out;
6775                 if (key.type == BTRFS_ROOT_ITEM_KEY &&
6776                     fs_root_objectid(key.objectid)) {
6777                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
6778                                 cur_root = btrfs_read_fs_root_no_cache(fs_info,
6779                                                                        &key);
6780                         } else {
6781                                 key.offset = (u64)-1;
6782                                 cur_root = btrfs_read_fs_root(fs_info, &key);
6783                         }
6784
6785                         if (IS_ERR(cur_root)) {
6786                                 error("Fail to read fs/subvol tree: %lld",
6787                                       key.objectid);
6788                                 err = -EIO;
6789                                 goto next;
6790                         }
6791
6792                         ret = check_fs_root_v2(cur_root, ext_ref);
6793                         err |= ret;
6794
6795                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
6796                                 btrfs_free_fs_root(cur_root);
6797                 } else if (key.type == BTRFS_ROOT_REF_KEY ||
6798                                 key.type == BTRFS_ROOT_BACKREF_KEY) {
6799                         ret = check_root_ref(tree_root, &key, node, slot);
6800                         err |= ret;
6801                 }
6802 next:
6803                 ret = btrfs_next_item(tree_root, &path);
6804                 if (ret > 0)
6805                         goto out;
6806                 if (ret < 0) {
6807                         err = ret;
6808                         goto out;
6809                 }
6810         }
6811
6812 out:
6813         btrfs_release_path(&path);
6814         return err;
6815 }
6816
6817 static int do_check_fs_roots(struct btrfs_fs_info *fs_info,
6818                           struct cache_tree *root_cache)
6819 {
6820         int ret;
6821
6822         if (!ctx.progress_enabled)
6823                 fprintf(stderr, "checking fs roots\n");
6824         if (check_mode == CHECK_MODE_LOWMEM)
6825                 ret = check_fs_roots_v2(fs_info);
6826         else
6827                 ret = check_fs_roots(fs_info, root_cache);
6828
6829         return ret;
6830 }
6831
6832 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
6833 {
6834         struct extent_backref *back, *tmp;
6835         struct tree_backref *tback;
6836         struct data_backref *dback;
6837         u64 found = 0;
6838         int err = 0;
6839
6840         rbtree_postorder_for_each_entry_safe(back, tmp,
6841                                              &rec->backref_tree, node) {
6842                 if (!back->found_extent_tree) {
6843                         err = 1;
6844                         if (!print_errs)
6845                                 goto out;
6846                         if (back->is_data) {
6847                                 dback = to_data_backref(back);
6848                                 fprintf(stderr, "Data backref %llu %s %llu"
6849                                         " owner %llu offset %llu num_refs %lu"
6850                                         " not found in extent tree\n",
6851                                         (unsigned long long)rec->start,
6852                                         back->full_backref ?
6853                                         "parent" : "root",
6854                                         back->full_backref ?
6855                                         (unsigned long long)dback->parent:
6856                                         (unsigned long long)dback->root,
6857                                         (unsigned long long)dback->owner,
6858                                         (unsigned long long)dback->offset,
6859                                         (unsigned long)dback->num_refs);
6860                         } else {
6861                                 tback = to_tree_backref(back);
6862                                 fprintf(stderr, "Tree backref %llu parent %llu"
6863                                         " root %llu not found in extent tree\n",
6864                                         (unsigned long long)rec->start,
6865                                         (unsigned long long)tback->parent,
6866                                         (unsigned long long)tback->root);
6867                         }
6868                 }
6869                 if (!back->is_data && !back->found_ref) {
6870                         err = 1;
6871                         if (!print_errs)
6872                                 goto out;
6873                         tback = to_tree_backref(back);
6874                         fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
6875                                 (unsigned long long)rec->start,
6876                                 back->full_backref ? "parent" : "root",
6877                                 back->full_backref ?
6878                                 (unsigned long long)tback->parent :
6879                                 (unsigned long long)tback->root, back);
6880                 }
6881                 if (back->is_data) {
6882                         dback = to_data_backref(back);
6883                         if (dback->found_ref != dback->num_refs) {
6884                                 err = 1;
6885                                 if (!print_errs)
6886                                         goto out;
6887                                 fprintf(stderr, "Incorrect local backref count"
6888                                         " on %llu %s %llu owner %llu"
6889                                         " offset %llu found %u wanted %u back %p\n",
6890                                         (unsigned long long)rec->start,
6891                                         back->full_backref ?
6892                                         "parent" : "root",
6893                                         back->full_backref ?
6894                                         (unsigned long long)dback->parent:
6895                                         (unsigned long long)dback->root,
6896                                         (unsigned long long)dback->owner,
6897                                         (unsigned long long)dback->offset,
6898                                         dback->found_ref, dback->num_refs, back);
6899                         }
6900                         if (dback->disk_bytenr != rec->start) {
6901                                 err = 1;
6902                                 if (!print_errs)
6903                                         goto out;
6904                                 fprintf(stderr, "Backref disk bytenr does not"
6905                                         " match extent record, bytenr=%llu, "
6906                                         "ref bytenr=%llu\n",
6907                                         (unsigned long long)rec->start,
6908                                         (unsigned long long)dback->disk_bytenr);
6909                         }
6910
6911                         if (dback->bytes != rec->nr) {
6912                                 err = 1;
6913                                 if (!print_errs)
6914                                         goto out;
6915                                 fprintf(stderr, "Backref bytes do not match "
6916                                         "extent backref, bytenr=%llu, ref "
6917                                         "bytes=%llu, backref bytes=%llu\n",
6918                                         (unsigned long long)rec->start,
6919                                         (unsigned long long)rec->nr,
6920                                         (unsigned long long)dback->bytes);
6921                         }
6922                 }
6923                 if (!back->is_data) {
6924                         found += 1;
6925                 } else {
6926                         dback = to_data_backref(back);
6927                         found += dback->found_ref;
6928                 }
6929         }
6930         if (found != rec->refs) {
6931                 err = 1;
6932                 if (!print_errs)
6933                         goto out;
6934                 fprintf(stderr, "Incorrect global backref count "
6935                         "on %llu found %llu wanted %llu\n",
6936                         (unsigned long long)rec->start,
6937                         (unsigned long long)found,
6938                         (unsigned long long)rec->refs);
6939         }
6940 out:
6941         return err;
6942 }
6943
6944 static void __free_one_backref(struct rb_node *node)
6945 {
6946         struct extent_backref *back = rb_node_to_extent_backref(node);
6947
6948         free(back);
6949 }
6950
6951 static void free_all_extent_backrefs(struct extent_record *rec)
6952 {
6953         rb_free_nodes(&rec->backref_tree, __free_one_backref);
6954 }
6955
6956 static void free_extent_record_cache(struct cache_tree *extent_cache)
6957 {
6958         struct cache_extent *cache;
6959         struct extent_record *rec;
6960
6961         while (1) {
6962                 cache = first_cache_extent(extent_cache);
6963                 if (!cache)
6964                         break;
6965                 rec = container_of(cache, struct extent_record, cache);
6966                 remove_cache_extent(extent_cache, cache);
6967                 free_all_extent_backrefs(rec);
6968                 free(rec);
6969         }
6970 }
6971
6972 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
6973                                  struct extent_record *rec)
6974 {
6975         if (rec->content_checked && rec->owner_ref_checked &&
6976             rec->extent_item_refs == rec->refs && rec->refs > 0 &&
6977             rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
6978             !rec->bad_full_backref && !rec->crossing_stripes &&
6979             !rec->wrong_chunk_type) {
6980                 remove_cache_extent(extent_cache, &rec->cache);
6981                 free_all_extent_backrefs(rec);
6982                 list_del_init(&rec->list);
6983                 free(rec);
6984         }
6985         return 0;
6986 }
6987
6988 static int check_owner_ref(struct btrfs_root *root,
6989                             struct extent_record *rec,
6990                             struct extent_buffer *buf)
6991 {
6992         struct extent_backref *node, *tmp;
6993         struct tree_backref *back;
6994         struct btrfs_root *ref_root;
6995         struct btrfs_key key;
6996         struct btrfs_path path;
6997         struct extent_buffer *parent;
6998         int level;
6999         int found = 0;
7000         int ret;
7001
7002         rbtree_postorder_for_each_entry_safe(node, tmp,
7003                                              &rec->backref_tree, node) {
7004                 if (node->is_data)
7005                         continue;
7006                 if (!node->found_ref)
7007                         continue;
7008                 if (node->full_backref)
7009                         continue;
7010                 back = to_tree_backref(node);
7011                 if (btrfs_header_owner(buf) == back->root)
7012                         return 0;
7013         }
7014         BUG_ON(rec->is_root);
7015
7016         /* try to find the block by search corresponding fs tree */
7017         key.objectid = btrfs_header_owner(buf);
7018         key.type = BTRFS_ROOT_ITEM_KEY;
7019         key.offset = (u64)-1;
7020
7021         ref_root = btrfs_read_fs_root(root->fs_info, &key);
7022         if (IS_ERR(ref_root))
7023                 return 1;
7024
7025         level = btrfs_header_level(buf);
7026         if (level == 0)
7027                 btrfs_item_key_to_cpu(buf, &key, 0);
7028         else
7029                 btrfs_node_key_to_cpu(buf, &key, 0);
7030
7031         btrfs_init_path(&path);
7032         path.lowest_level = level + 1;
7033         ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
7034         if (ret < 0)
7035                 return 0;
7036
7037         parent = path.nodes[level + 1];
7038         if (parent && buf->start == btrfs_node_blockptr(parent,
7039                                                         path.slots[level + 1]))
7040                 found = 1;
7041
7042         btrfs_release_path(&path);
7043         return found ? 0 : 1;
7044 }
7045
7046 static int is_extent_tree_record(struct extent_record *rec)
7047 {
7048         struct extent_backref *node, *tmp;
7049         struct tree_backref *back;
7050         int is_extent = 0;
7051
7052         rbtree_postorder_for_each_entry_safe(node, tmp,
7053                                              &rec->backref_tree, node) {
7054                 if (node->is_data)
7055                         return 0;
7056                 back = to_tree_backref(node);
7057                 if (node->full_backref)
7058                         return 0;
7059                 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
7060                         is_extent = 1;
7061         }
7062         return is_extent;
7063 }
7064
7065
7066 static int record_bad_block_io(struct btrfs_fs_info *info,
7067                                struct cache_tree *extent_cache,
7068                                u64 start, u64 len)
7069 {
7070         struct extent_record *rec;
7071         struct cache_extent *cache;
7072         struct btrfs_key key;
7073
7074         cache = lookup_cache_extent(extent_cache, start, len);
7075         if (!cache)
7076                 return 0;
7077
7078         rec = container_of(cache, struct extent_record, cache);
7079         if (!is_extent_tree_record(rec))
7080                 return 0;
7081
7082         btrfs_disk_key_to_cpu(&key, &rec->parent_key);
7083         return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
7084 }
7085
7086 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
7087                        struct extent_buffer *buf, int slot)
7088 {
7089         if (btrfs_header_level(buf)) {
7090                 struct btrfs_key_ptr ptr1, ptr2;
7091
7092                 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
7093                                    sizeof(struct btrfs_key_ptr));
7094                 read_extent_buffer(buf, &ptr2,
7095                                    btrfs_node_key_ptr_offset(slot + 1),
7096                                    sizeof(struct btrfs_key_ptr));
7097                 write_extent_buffer(buf, &ptr1,
7098                                     btrfs_node_key_ptr_offset(slot + 1),
7099                                     sizeof(struct btrfs_key_ptr));
7100                 write_extent_buffer(buf, &ptr2,
7101                                     btrfs_node_key_ptr_offset(slot),
7102                                     sizeof(struct btrfs_key_ptr));
7103                 if (slot == 0) {
7104                         struct btrfs_disk_key key;
7105                         btrfs_node_key(buf, &key, 0);
7106                         btrfs_fixup_low_keys(root, path, &key,
7107                                              btrfs_header_level(buf) + 1);
7108                 }
7109         } else {
7110                 struct btrfs_item *item1, *item2;
7111                 struct btrfs_key k1, k2;
7112                 char *item1_data, *item2_data;
7113                 u32 item1_offset, item2_offset, item1_size, item2_size;
7114
7115                 item1 = btrfs_item_nr(slot);
7116                 item2 = btrfs_item_nr(slot + 1);
7117                 btrfs_item_key_to_cpu(buf, &k1, slot);
7118                 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
7119                 item1_offset = btrfs_item_offset(buf, item1);
7120                 item2_offset = btrfs_item_offset(buf, item2);
7121                 item1_size = btrfs_item_size(buf, item1);
7122                 item2_size = btrfs_item_size(buf, item2);
7123
7124                 item1_data = malloc(item1_size);
7125                 if (!item1_data)
7126                         return -ENOMEM;
7127                 item2_data = malloc(item2_size);
7128                 if (!item2_data) {
7129                         free(item1_data);
7130                         return -ENOMEM;
7131                 }
7132
7133                 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
7134                 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
7135
7136                 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
7137                 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
7138                 free(item1_data);
7139                 free(item2_data);
7140
7141                 btrfs_set_item_offset(buf, item1, item2_offset);
7142                 btrfs_set_item_offset(buf, item2, item1_offset);
7143                 btrfs_set_item_size(buf, item1, item2_size);
7144                 btrfs_set_item_size(buf, item2, item1_size);
7145
7146                 path->slots[0] = slot;
7147                 btrfs_set_item_key_unsafe(root, path, &k2);
7148                 path->slots[0] = slot + 1;
7149                 btrfs_set_item_key_unsafe(root, path, &k1);
7150         }
7151         return 0;
7152 }
7153
7154 static int fix_key_order(struct btrfs_root *root, struct btrfs_path *path)
7155 {
7156         struct extent_buffer *buf;
7157         struct btrfs_key k1, k2;
7158         int i;
7159         int level = path->lowest_level;
7160         int ret = -EIO;
7161
7162         buf = path->nodes[level];
7163         for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
7164                 if (level) {
7165                         btrfs_node_key_to_cpu(buf, &k1, i);
7166                         btrfs_node_key_to_cpu(buf, &k2, i + 1);
7167                 } else {
7168                         btrfs_item_key_to_cpu(buf, &k1, i);
7169                         btrfs_item_key_to_cpu(buf, &k2, i + 1);
7170                 }
7171                 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
7172                         continue;
7173                 ret = swap_values(root, path, buf, i);
7174                 if (ret)
7175                         break;
7176                 btrfs_mark_buffer_dirty(buf);
7177                 i = 0;
7178         }
7179         return ret;
7180 }
7181
7182 static int delete_bogus_item(struct btrfs_root *root,
7183                              struct btrfs_path *path,
7184                              struct extent_buffer *buf, int slot)
7185 {
7186         struct btrfs_key key;
7187         int nritems = btrfs_header_nritems(buf);
7188
7189         btrfs_item_key_to_cpu(buf, &key, slot);
7190
7191         /* These are all the keys we can deal with missing. */
7192         if (key.type != BTRFS_DIR_INDEX_KEY &&
7193             key.type != BTRFS_EXTENT_ITEM_KEY &&
7194             key.type != BTRFS_METADATA_ITEM_KEY &&
7195             key.type != BTRFS_TREE_BLOCK_REF_KEY &&
7196             key.type != BTRFS_EXTENT_DATA_REF_KEY)
7197                 return -1;
7198
7199         printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
7200                (unsigned long long)key.objectid, key.type,
7201                (unsigned long long)key.offset, slot, buf->start);
7202         memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
7203                               btrfs_item_nr_offset(slot + 1),
7204                               sizeof(struct btrfs_item) *
7205                               (nritems - slot - 1));
7206         btrfs_set_header_nritems(buf, nritems - 1);
7207         if (slot == 0) {
7208                 struct btrfs_disk_key disk_key;
7209
7210                 btrfs_item_key(buf, &disk_key, 0);
7211                 btrfs_fixup_low_keys(root, path, &disk_key, 1);
7212         }
7213         btrfs_mark_buffer_dirty(buf);
7214         return 0;
7215 }
7216
7217 static int fix_item_offset(struct btrfs_root *root, struct btrfs_path *path)
7218 {
7219         struct extent_buffer *buf;
7220         int i;
7221         int ret = 0;
7222
7223         /* We should only get this for leaves */
7224         BUG_ON(path->lowest_level);
7225         buf = path->nodes[0];
7226 again:
7227         for (i = 0; i < btrfs_header_nritems(buf); i++) {
7228                 unsigned int shift = 0, offset;
7229
7230                 if (i == 0 && btrfs_item_end_nr(buf, i) !=
7231                     BTRFS_LEAF_DATA_SIZE(root)) {
7232                         if (btrfs_item_end_nr(buf, i) >
7233                             BTRFS_LEAF_DATA_SIZE(root)) {
7234                                 ret = delete_bogus_item(root, path, buf, i);
7235                                 if (!ret)
7236                                         goto again;
7237                                 fprintf(stderr, "item is off the end of the "
7238                                         "leaf, can't fix\n");
7239                                 ret = -EIO;
7240                                 break;
7241                         }
7242                         shift = BTRFS_LEAF_DATA_SIZE(root) -
7243                                 btrfs_item_end_nr(buf, i);
7244                 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
7245                            btrfs_item_offset_nr(buf, i - 1)) {
7246                         if (btrfs_item_end_nr(buf, i) >
7247                             btrfs_item_offset_nr(buf, i - 1)) {
7248                                 ret = delete_bogus_item(root, path, buf, i);
7249                                 if (!ret)
7250                                         goto again;
7251                                 fprintf(stderr, "items overlap, can't fix\n");
7252                                 ret = -EIO;
7253                                 break;
7254                         }
7255                         shift = btrfs_item_offset_nr(buf, i - 1) -
7256                                 btrfs_item_end_nr(buf, i);
7257                 }
7258                 if (!shift)
7259                         continue;
7260
7261                 printf("Shifting item nr %d by %u bytes in block %llu\n",
7262                        i, shift, (unsigned long long)buf->start);
7263                 offset = btrfs_item_offset_nr(buf, i);
7264                 memmove_extent_buffer(buf,
7265                                       btrfs_leaf_data(buf) + offset + shift,
7266                                       btrfs_leaf_data(buf) + offset,
7267                                       btrfs_item_size_nr(buf, i));
7268                 btrfs_set_item_offset(buf, btrfs_item_nr(i),
7269                                       offset + shift);
7270                 btrfs_mark_buffer_dirty(buf);
7271         }
7272
7273         /*
7274          * We may have moved things, in which case we want to exit so we don't
7275          * write those changes out.  Once we have proper abort functionality in
7276          * progs this can be changed to something nicer.
7277          */
7278         BUG_ON(ret);
7279         return ret;
7280 }
7281
7282 /*
7283  * Attempt to fix basic block failures.  If we can't fix it for whatever reason
7284  * then just return -EIO.
7285  */
7286 static int try_to_fix_bad_block(struct btrfs_root *root,
7287                                 struct extent_buffer *buf,
7288                                 enum btrfs_tree_block_status status)
7289 {
7290         struct btrfs_trans_handle *trans;
7291         struct ulist *roots;
7292         struct ulist_node *node;
7293         struct btrfs_root *search_root;
7294         struct btrfs_path path;
7295         struct ulist_iterator iter;
7296         struct btrfs_key root_key, key;
7297         int ret;
7298
7299         if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
7300             status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
7301                 return -EIO;
7302
7303         ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
7304         if (ret)
7305                 return -EIO;
7306
7307         btrfs_init_path(&path);
7308         ULIST_ITER_INIT(&iter);
7309         while ((node = ulist_next(roots, &iter))) {
7310                 root_key.objectid = node->val;
7311                 root_key.type = BTRFS_ROOT_ITEM_KEY;
7312                 root_key.offset = (u64)-1;
7313
7314                 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
7315                 if (IS_ERR(root)) {
7316                         ret = -EIO;
7317                         break;
7318                 }
7319
7320
7321                 trans = btrfs_start_transaction(search_root, 0);
7322                 if (IS_ERR(trans)) {
7323                         ret = PTR_ERR(trans);
7324                         break;
7325                 }
7326
7327                 path.lowest_level = btrfs_header_level(buf);
7328                 path.skip_check_block = 1;
7329                 if (path.lowest_level)
7330                         btrfs_node_key_to_cpu(buf, &key, 0);
7331                 else
7332                         btrfs_item_key_to_cpu(buf, &key, 0);
7333                 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
7334                 if (ret) {
7335                         ret = -EIO;
7336                         btrfs_commit_transaction(trans, search_root);
7337                         break;
7338                 }
7339                 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
7340                         ret = fix_key_order(search_root, &path);
7341                 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
7342                         ret = fix_item_offset(search_root, &path);
7343                 if (ret) {
7344                         btrfs_commit_transaction(trans, search_root);
7345                         break;
7346                 }
7347                 btrfs_release_path(&path);
7348                 btrfs_commit_transaction(trans, search_root);
7349         }
7350         ulist_free(roots);
7351         btrfs_release_path(&path);
7352         return ret;
7353 }
7354
7355 static int check_block(struct btrfs_root *root,
7356                        struct cache_tree *extent_cache,
7357                        struct extent_buffer *buf, u64 flags)
7358 {
7359         struct extent_record *rec;
7360         struct cache_extent *cache;
7361         struct btrfs_key key;
7362         enum btrfs_tree_block_status status;
7363         int ret = 0;
7364         int level;
7365
7366         cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
7367         if (!cache)
7368                 return 1;
7369         rec = container_of(cache, struct extent_record, cache);
7370         rec->generation = btrfs_header_generation(buf);
7371
7372         level = btrfs_header_level(buf);
7373         if (btrfs_header_nritems(buf) > 0) {
7374
7375                 if (level == 0)
7376                         btrfs_item_key_to_cpu(buf, &key, 0);
7377                 else
7378                         btrfs_node_key_to_cpu(buf, &key, 0);
7379
7380                 rec->info_objectid = key.objectid;
7381         }
7382         rec->info_level = level;
7383
7384         if (btrfs_is_leaf(buf))
7385                 status = btrfs_check_leaf(root, &rec->parent_key, buf);
7386         else
7387                 status = btrfs_check_node(root, &rec->parent_key, buf);
7388
7389         if (status != BTRFS_TREE_BLOCK_CLEAN) {
7390                 if (repair)
7391                         status = try_to_fix_bad_block(root, buf, status);
7392                 if (status != BTRFS_TREE_BLOCK_CLEAN) {
7393                         ret = -EIO;
7394                         fprintf(stderr, "bad block %llu\n",
7395                                 (unsigned long long)buf->start);
7396                 } else {
7397                         /*
7398                          * Signal to callers we need to start the scan over
7399                          * again since we'll have cowed blocks.
7400                          */
7401                         ret = -EAGAIN;
7402                 }
7403         } else {
7404                 rec->content_checked = 1;
7405                 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
7406                         rec->owner_ref_checked = 1;
7407                 else {
7408                         ret = check_owner_ref(root, rec, buf);
7409                         if (!ret)
7410                                 rec->owner_ref_checked = 1;
7411                 }
7412         }
7413         if (!ret)
7414                 maybe_free_extent_rec(extent_cache, rec);
7415         return ret;
7416 }
7417
7418 #if 0
7419 static struct tree_backref *find_tree_backref(struct extent_record *rec,
7420                                                 u64 parent, u64 root)
7421 {
7422         struct list_head *cur = rec->backrefs.next;
7423         struct extent_backref *node;
7424         struct tree_backref *back;
7425
7426         while(cur != &rec->backrefs) {
7427                 node = to_extent_backref(cur);
7428                 cur = cur->next;
7429                 if (node->is_data)
7430                         continue;
7431                 back = to_tree_backref(node);
7432                 if (parent > 0) {
7433                         if (!node->full_backref)
7434                                 continue;
7435                         if (parent == back->parent)
7436                                 return back;
7437                 } else {
7438                         if (node->full_backref)
7439                                 continue;
7440                         if (back->root == root)
7441                                 return back;
7442                 }
7443         }
7444         return NULL;
7445 }
7446 #endif
7447
7448 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
7449                                                 u64 parent, u64 root)
7450 {
7451         struct tree_backref *ref = malloc(sizeof(*ref));
7452
7453         if (!ref)
7454                 return NULL;
7455         memset(&ref->node, 0, sizeof(ref->node));
7456         if (parent > 0) {
7457                 ref->parent = parent;
7458                 ref->node.full_backref = 1;
7459         } else {
7460                 ref->root = root;
7461                 ref->node.full_backref = 0;
7462         }
7463
7464         return ref;
7465 }
7466
7467 #if 0
7468 static struct data_backref *find_data_backref(struct extent_record *rec,
7469                                                 u64 parent, u64 root,
7470                                                 u64 owner, u64 offset,
7471                                                 int found_ref,
7472                                                 u64 disk_bytenr, u64 bytes)
7473 {
7474         struct list_head *cur = rec->backrefs.next;
7475         struct extent_backref *node;
7476         struct data_backref *back;
7477
7478         while(cur != &rec->backrefs) {
7479                 node = to_extent_backref(cur);
7480                 cur = cur->next;
7481                 if (!node->is_data)
7482                         continue;
7483                 back = to_data_backref(node);
7484                 if (parent > 0) {
7485                         if (!node->full_backref)
7486                                 continue;
7487                         if (parent == back->parent)
7488                                 return back;
7489                 } else {
7490                         if (node->full_backref)
7491                                 continue;
7492                         if (back->root == root && back->owner == owner &&
7493                             back->offset == offset) {
7494                                 if (found_ref && node->found_ref &&
7495                                     (back->bytes != bytes ||
7496                                     back->disk_bytenr != disk_bytenr))
7497                                         continue;
7498                                 return back;
7499                         }
7500                 }
7501         }
7502         return NULL;
7503 }
7504 #endif
7505
7506 static struct data_backref *alloc_data_backref(struct extent_record *rec,
7507                                                 u64 parent, u64 root,
7508                                                 u64 owner, u64 offset,
7509                                                 u64 max_size)
7510 {
7511         struct data_backref *ref = malloc(sizeof(*ref));
7512
7513         if (!ref)
7514                 return NULL;
7515         memset(&ref->node, 0, sizeof(ref->node));
7516         ref->node.is_data = 1;
7517
7518         if (parent > 0) {
7519                 ref->parent = parent;
7520                 ref->owner = 0;
7521                 ref->offset = 0;
7522                 ref->node.full_backref = 1;
7523         } else {
7524                 ref->root = root;
7525                 ref->owner = owner;
7526                 ref->offset = offset;
7527                 ref->node.full_backref = 0;
7528         }
7529         ref->bytes = max_size;
7530         ref->found_ref = 0;
7531         ref->num_refs = 0;
7532         if (max_size > rec->max_size)
7533                 rec->max_size = max_size;
7534         return ref;
7535 }
7536
7537 /* Check if the type of extent matches with its chunk */
7538 static void check_extent_type(struct extent_record *rec)
7539 {
7540         struct btrfs_block_group_cache *bg_cache;
7541
7542         bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
7543         if (!bg_cache)
7544                 return;
7545
7546         /* data extent, check chunk directly*/
7547         if (!rec->metadata) {
7548                 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
7549                         rec->wrong_chunk_type = 1;
7550                 return;
7551         }
7552
7553         /* metadata extent, check the obvious case first */
7554         if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
7555                                  BTRFS_BLOCK_GROUP_METADATA))) {
7556                 rec->wrong_chunk_type = 1;
7557                 return;
7558         }
7559
7560         /*
7561          * Check SYSTEM extent, as it's also marked as metadata, we can only
7562          * make sure it's a SYSTEM extent by its backref
7563          */
7564         if (!RB_EMPTY_ROOT(&rec->backref_tree)) {
7565                 struct extent_backref *node;
7566                 struct tree_backref *tback;
7567                 u64 bg_type;
7568
7569                 node = rb_node_to_extent_backref(rb_first(&rec->backref_tree));
7570                 if (node->is_data) {
7571                         /* tree block shouldn't have data backref */
7572                         rec->wrong_chunk_type = 1;
7573                         return;
7574                 }
7575                 tback = container_of(node, struct tree_backref, node);
7576
7577                 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
7578                         bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
7579                 else
7580                         bg_type = BTRFS_BLOCK_GROUP_METADATA;
7581                 if (!(bg_cache->flags & bg_type))
7582                         rec->wrong_chunk_type = 1;
7583         }
7584 }
7585
7586 /*
7587  * Allocate a new extent record, fill default values from @tmpl and insert int
7588  * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
7589  * the cache, otherwise it fails.
7590  */
7591 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
7592                 struct extent_record *tmpl)
7593 {
7594         struct extent_record *rec;
7595         int ret = 0;
7596
7597         BUG_ON(tmpl->max_size == 0);
7598         rec = malloc(sizeof(*rec));
7599         if (!rec)
7600                 return -ENOMEM;
7601         rec->start = tmpl->start;
7602         rec->max_size = tmpl->max_size;
7603         rec->nr = max(tmpl->nr, tmpl->max_size);
7604         rec->found_rec = tmpl->found_rec;
7605         rec->content_checked = tmpl->content_checked;
7606         rec->owner_ref_checked = tmpl->owner_ref_checked;
7607         rec->num_duplicates = 0;
7608         rec->metadata = tmpl->metadata;
7609         rec->flag_block_full_backref = FLAG_UNSET;
7610         rec->bad_full_backref = 0;
7611         rec->crossing_stripes = 0;
7612         rec->wrong_chunk_type = 0;
7613         rec->is_root = tmpl->is_root;
7614         rec->refs = tmpl->refs;
7615         rec->extent_item_refs = tmpl->extent_item_refs;
7616         rec->parent_generation = tmpl->parent_generation;
7617         INIT_LIST_HEAD(&rec->backrefs);
7618         INIT_LIST_HEAD(&rec->dups);
7619         INIT_LIST_HEAD(&rec->list);
7620         rec->backref_tree = RB_ROOT;
7621         memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
7622         rec->cache.start = tmpl->start;
7623         rec->cache.size = tmpl->nr;
7624         ret = insert_cache_extent(extent_cache, &rec->cache);
7625         if (ret) {
7626                 free(rec);
7627                 return ret;
7628         }
7629         bytes_used += rec->nr;
7630
7631         if (tmpl->metadata)
7632                 rec->crossing_stripes = check_crossing_stripes(global_info,
7633                                 rec->start, global_info->nodesize);
7634         check_extent_type(rec);
7635         return ret;
7636 }
7637
7638 /*
7639  * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
7640  * some are hints:
7641  * - refs              - if found, increase refs
7642  * - is_root           - if found, set
7643  * - content_checked   - if found, set
7644  * - owner_ref_checked - if found, set
7645  *
7646  * If not found, create a new one, initialize and insert.
7647  */
7648 static int add_extent_rec(struct cache_tree *extent_cache,
7649                 struct extent_record *tmpl)
7650 {
7651         struct extent_record *rec;
7652         struct cache_extent *cache;
7653         int ret = 0;
7654         int dup = 0;
7655
7656         cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
7657         if (cache) {
7658                 rec = container_of(cache, struct extent_record, cache);
7659                 if (tmpl->refs)
7660                         rec->refs++;
7661                 if (rec->nr == 1)
7662                         rec->nr = max(tmpl->nr, tmpl->max_size);
7663
7664                 /*
7665                  * We need to make sure to reset nr to whatever the extent
7666                  * record says was the real size, this way we can compare it to
7667                  * the backrefs.
7668                  */
7669                 if (tmpl->found_rec) {
7670                         if (tmpl->start != rec->start || rec->found_rec) {
7671                                 struct extent_record *tmp;
7672
7673                                 dup = 1;
7674                                 if (list_empty(&rec->list))
7675                                         list_add_tail(&rec->list,
7676                                                       &duplicate_extents);
7677
7678                                 /*
7679                                  * We have to do this song and dance in case we
7680                                  * find an extent record that falls inside of
7681                                  * our current extent record but does not have
7682                                  * the same objectid.
7683                                  */
7684                                 tmp = malloc(sizeof(*tmp));
7685                                 if (!tmp)
7686                                         return -ENOMEM;
7687                                 tmp->start = tmpl->start;
7688                                 tmp->max_size = tmpl->max_size;
7689                                 tmp->nr = tmpl->nr;
7690                                 tmp->found_rec = 1;
7691                                 tmp->metadata = tmpl->metadata;
7692                                 tmp->extent_item_refs = tmpl->extent_item_refs;
7693                                 INIT_LIST_HEAD(&tmp->list);
7694                                 list_add_tail(&tmp->list, &rec->dups);
7695                                 rec->num_duplicates++;
7696                         } else {
7697                                 rec->nr = tmpl->nr;
7698                                 rec->found_rec = 1;
7699                         }
7700                 }
7701
7702                 if (tmpl->extent_item_refs && !dup) {
7703                         if (rec->extent_item_refs) {
7704                                 fprintf(stderr, "block %llu rec "
7705                                         "extent_item_refs %llu, passed %llu\n",
7706                                         (unsigned long long)tmpl->start,
7707                                         (unsigned long long)
7708                                                         rec->extent_item_refs,
7709                                         (unsigned long long)tmpl->extent_item_refs);
7710                         }
7711                         rec->extent_item_refs = tmpl->extent_item_refs;
7712                 }
7713                 if (tmpl->is_root)
7714                         rec->is_root = 1;
7715                 if (tmpl->content_checked)
7716                         rec->content_checked = 1;
7717                 if (tmpl->owner_ref_checked)
7718                         rec->owner_ref_checked = 1;
7719                 memcpy(&rec->parent_key, &tmpl->parent_key,
7720                                 sizeof(tmpl->parent_key));
7721                 if (tmpl->parent_generation)
7722                         rec->parent_generation = tmpl->parent_generation;
7723                 if (rec->max_size < tmpl->max_size)
7724                         rec->max_size = tmpl->max_size;
7725
7726                 /*
7727                  * A metadata extent can't cross stripe_len boundary, otherwise
7728                  * kernel scrub won't be able to handle it.
7729                  * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
7730                  * it.
7731                  */
7732                 if (tmpl->metadata)
7733                         rec->crossing_stripes = check_crossing_stripes(
7734                                         global_info, rec->start,
7735                                         global_info->nodesize);
7736                 check_extent_type(rec);
7737                 maybe_free_extent_rec(extent_cache, rec);
7738                 return ret;
7739         }
7740
7741         ret = add_extent_rec_nolookup(extent_cache, tmpl);
7742
7743         return ret;
7744 }
7745
7746 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
7747                             u64 parent, u64 root, int found_ref)
7748 {
7749         struct extent_record *rec;
7750         struct tree_backref *back;
7751         struct cache_extent *cache;
7752         int ret;
7753         bool insert = false;
7754
7755         cache = lookup_cache_extent(extent_cache, bytenr, 1);
7756         if (!cache) {
7757                 struct extent_record tmpl;
7758
7759                 memset(&tmpl, 0, sizeof(tmpl));
7760                 tmpl.start = bytenr;
7761                 tmpl.nr = 1;
7762                 tmpl.metadata = 1;
7763                 tmpl.max_size = 1;
7764
7765                 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
7766                 if (ret)
7767                         return ret;
7768
7769                 /* really a bug in cache_extent implement now */
7770                 cache = lookup_cache_extent(extent_cache, bytenr, 1);
7771                 if (!cache)
7772                         return -ENOENT;
7773         }
7774
7775         rec = container_of(cache, struct extent_record, cache);
7776         if (rec->start != bytenr) {
7777                 /*
7778                  * Several cause, from unaligned bytenr to over lapping extents
7779                  */
7780                 return -EEXIST;
7781         }
7782
7783         back = find_tree_backref(rec, parent, root);
7784         if (!back) {
7785                 back = alloc_tree_backref(rec, parent, root);
7786                 if (!back)
7787                         return -ENOMEM;
7788                 insert = true;
7789         }
7790
7791         if (found_ref) {
7792                 if (back->node.found_ref) {
7793                         fprintf(stderr, "Extent back ref already exists "
7794                                 "for %llu parent %llu root %llu \n",
7795                                 (unsigned long long)bytenr,
7796                                 (unsigned long long)parent,
7797                                 (unsigned long long)root);
7798                 }
7799                 back->node.found_ref = 1;
7800         } else {
7801                 if (back->node.found_extent_tree) {
7802                         fprintf(stderr, "Extent back ref already exists "
7803                                 "for %llu parent %llu root %llu \n",
7804                                 (unsigned long long)bytenr,
7805                                 (unsigned long long)parent,
7806                                 (unsigned long long)root);
7807                 }
7808                 back->node.found_extent_tree = 1;
7809         }
7810         if (insert)
7811                 WARN_ON(rb_insert(&rec->backref_tree, &back->node.node,
7812                         compare_extent_backref));
7813         check_extent_type(rec);
7814         maybe_free_extent_rec(extent_cache, rec);
7815         return 0;
7816 }
7817
7818 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
7819                             u64 parent, u64 root, u64 owner, u64 offset,
7820                             u32 num_refs, int found_ref, u64 max_size)
7821 {
7822         struct extent_record *rec;
7823         struct data_backref *back;
7824         struct cache_extent *cache;
7825         int ret;
7826         bool insert = false;
7827
7828         cache = lookup_cache_extent(extent_cache, bytenr, 1);
7829         if (!cache) {
7830                 struct extent_record tmpl;
7831
7832                 memset(&tmpl, 0, sizeof(tmpl));
7833                 tmpl.start = bytenr;
7834                 tmpl.nr = 1;
7835                 tmpl.max_size = max_size;
7836
7837                 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
7838                 if (ret)
7839                         return ret;
7840
7841                 cache = lookup_cache_extent(extent_cache, bytenr, 1);
7842                 if (!cache)
7843                         abort();
7844         }
7845
7846         rec = container_of(cache, struct extent_record, cache);
7847         if (rec->max_size < max_size)
7848                 rec->max_size = max_size;
7849
7850         /*
7851          * If found_ref is set then max_size is the real size and must match the
7852          * existing refs.  So if we have already found a ref then we need to
7853          * make sure that this ref matches the existing one, otherwise we need
7854          * to add a new backref so we can notice that the backrefs don't match
7855          * and we need to figure out who is telling the truth.  This is to
7856          * account for that awful fsync bug I introduced where we'd end up with
7857          * a btrfs_file_extent_item that would have its length include multiple
7858          * prealloc extents or point inside of a prealloc extent.
7859          */
7860         back = find_data_backref(rec, parent, root, owner, offset, found_ref,
7861                                  bytenr, max_size);
7862         if (!back) {
7863                 back = alloc_data_backref(rec, parent, root, owner, offset,
7864                                           max_size);
7865                 BUG_ON(!back);
7866                 insert = true;
7867         }
7868
7869         if (found_ref) {
7870                 BUG_ON(num_refs != 1);
7871                 if (back->node.found_ref)
7872                         BUG_ON(back->bytes != max_size);
7873                 back->node.found_ref = 1;
7874                 back->found_ref += 1;
7875                 if (back->bytes != max_size || back->disk_bytenr != bytenr) {
7876                         back->bytes = max_size;
7877                         back->disk_bytenr = bytenr;
7878
7879                         /* Need to reinsert if not already in the tree */
7880                         if (!insert) {
7881                                 rb_erase(&back->node.node, &rec->backref_tree);
7882                                 insert = true;
7883                         }
7884                 }
7885                 rec->refs += 1;
7886                 rec->content_checked = 1;
7887                 rec->owner_ref_checked = 1;
7888         } else {
7889                 if (back->node.found_extent_tree) {
7890                         fprintf(stderr, "Extent back ref already exists "
7891                                 "for %llu parent %llu root %llu "
7892                                 "owner %llu offset %llu num_refs %lu\n",
7893                                 (unsigned long long)bytenr,
7894                                 (unsigned long long)parent,
7895                                 (unsigned long long)root,
7896                                 (unsigned long long)owner,
7897                                 (unsigned long long)offset,
7898                                 (unsigned long)num_refs);
7899                 }
7900                 back->num_refs = num_refs;
7901                 back->node.found_extent_tree = 1;
7902         }
7903         if (insert)
7904                 WARN_ON(rb_insert(&rec->backref_tree, &back->node.node,
7905                         compare_extent_backref));
7906
7907         maybe_free_extent_rec(extent_cache, rec);
7908         return 0;
7909 }
7910
7911 static int add_pending(struct cache_tree *pending,
7912                        struct cache_tree *seen, u64 bytenr, u32 size)
7913 {
7914         int ret;
7915         ret = add_cache_extent(seen, bytenr, size);
7916         if (ret)
7917                 return ret;
7918         add_cache_extent(pending, bytenr, size);
7919         return 0;
7920 }
7921
7922 static int pick_next_pending(struct cache_tree *pending,
7923                         struct cache_tree *reada,
7924                         struct cache_tree *nodes,
7925                         u64 last, struct block_info *bits, int bits_nr,
7926                         int *reada_bits)
7927 {
7928         unsigned long node_start = last;
7929         struct cache_extent *cache;
7930         int ret;
7931
7932         cache = search_cache_extent(reada, 0);
7933         if (cache) {
7934                 bits[0].start = cache->start;
7935                 bits[0].size = cache->size;
7936                 *reada_bits = 1;
7937                 return 1;
7938         }
7939         *reada_bits = 0;
7940         if (node_start > 32768)
7941                 node_start -= 32768;
7942
7943         cache = search_cache_extent(nodes, node_start);
7944         if (!cache)
7945                 cache = search_cache_extent(nodes, 0);
7946
7947         if (!cache) {
7948                  cache = search_cache_extent(pending, 0);
7949                  if (!cache)
7950                          return 0;
7951                  ret = 0;
7952                  do {
7953                          bits[ret].start = cache->start;
7954                          bits[ret].size = cache->size;
7955                          cache = next_cache_extent(cache);
7956                          ret++;
7957                  } while (cache && ret < bits_nr);
7958                  return ret;
7959         }
7960
7961         ret = 0;
7962         do {
7963                 bits[ret].start = cache->start;
7964                 bits[ret].size = cache->size;
7965                 cache = next_cache_extent(cache);
7966                 ret++;
7967         } while (cache && ret < bits_nr);
7968
7969         if (bits_nr - ret > 8) {
7970                 u64 lookup = bits[0].start + bits[0].size;
7971                 struct cache_extent *next;
7972                 next = search_cache_extent(pending, lookup);
7973                 while(next) {
7974                         if (next->start - lookup > 32768)
7975                                 break;
7976                         bits[ret].start = next->start;
7977                         bits[ret].size = next->size;
7978                         lookup = next->start + next->size;
7979                         ret++;
7980                         if (ret == bits_nr)
7981                                 break;
7982                         next = next_cache_extent(next);
7983                         if (!next)
7984                                 break;
7985                 }
7986         }
7987         return ret;
7988 }
7989
7990 static void free_chunk_record(struct cache_extent *cache)
7991 {
7992         struct chunk_record *rec;
7993
7994         rec = container_of(cache, struct chunk_record, cache);
7995         list_del_init(&rec->list);
7996         list_del_init(&rec->dextents);
7997         free(rec);
7998 }
7999
8000 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
8001 {
8002         cache_tree_free_extents(chunk_cache, free_chunk_record);
8003 }
8004
8005 static void free_device_record(struct rb_node *node)
8006 {
8007         struct device_record *rec;
8008
8009         rec = container_of(node, struct device_record, node);
8010         free(rec);
8011 }
8012
8013 FREE_RB_BASED_TREE(device_cache, free_device_record);
8014
8015 int insert_block_group_record(struct block_group_tree *tree,
8016                               struct block_group_record *bg_rec)
8017 {
8018         int ret;
8019
8020         ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
8021         if (ret)
8022                 return ret;
8023
8024         list_add_tail(&bg_rec->list, &tree->block_groups);
8025         return 0;
8026 }
8027
8028 static void free_block_group_record(struct cache_extent *cache)
8029 {
8030         struct block_group_record *rec;
8031
8032         rec = container_of(cache, struct block_group_record, cache);
8033         list_del_init(&rec->list);
8034         free(rec);
8035 }
8036
8037 void free_block_group_tree(struct block_group_tree *tree)
8038 {
8039         cache_tree_free_extents(&tree->tree, free_block_group_record);
8040 }
8041
8042 int insert_device_extent_record(struct device_extent_tree *tree,
8043                                 struct device_extent_record *de_rec)
8044 {
8045         int ret;
8046
8047         /*
8048          * Device extent is a bit different from the other extents, because
8049          * the extents which belong to the different devices may have the
8050          * same start and size, so we need use the special extent cache
8051          * search/insert functions.
8052          */
8053         ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
8054         if (ret)
8055                 return ret;
8056
8057         list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
8058         list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
8059         return 0;
8060 }
8061
8062 static void free_device_extent_record(struct cache_extent *cache)
8063 {
8064         struct device_extent_record *rec;
8065
8066         rec = container_of(cache, struct device_extent_record, cache);
8067         if (!list_empty(&rec->chunk_list))
8068                 list_del_init(&rec->chunk_list);
8069         if (!list_empty(&rec->device_list))
8070                 list_del_init(&rec->device_list);
8071         free(rec);
8072 }
8073
8074 void free_device_extent_tree(struct device_extent_tree *tree)
8075 {
8076         cache_tree_free_extents(&tree->tree, free_device_extent_record);
8077 }
8078
8079 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
8080 static int process_extent_ref_v0(struct cache_tree *extent_cache,
8081                                  struct extent_buffer *leaf, int slot)
8082 {
8083         struct btrfs_extent_ref_v0 *ref0;
8084         struct btrfs_key key;
8085         int ret;
8086
8087         btrfs_item_key_to_cpu(leaf, &key, slot);
8088         ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
8089         if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
8090                 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
8091                                 0, 0);
8092         } else {
8093                 ret = add_data_backref(extent_cache, key.objectid, key.offset,
8094                                 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
8095         }
8096         return ret;
8097 }
8098 #endif
8099
8100 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
8101                                             struct btrfs_key *key,
8102                                             int slot)
8103 {
8104         struct btrfs_chunk *ptr;
8105         struct chunk_record *rec;
8106         int num_stripes, i;
8107
8108         ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
8109         num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
8110
8111         rec = calloc(1, btrfs_chunk_record_size(num_stripes));
8112         if (!rec) {
8113                 fprintf(stderr, "memory allocation failed\n");
8114                 exit(-1);
8115         }
8116
8117         INIT_LIST_HEAD(&rec->list);
8118         INIT_LIST_HEAD(&rec->dextents);
8119         rec->bg_rec = NULL;
8120
8121         rec->cache.start = key->offset;
8122         rec->cache.size = btrfs_chunk_length(leaf, ptr);
8123
8124         rec->generation = btrfs_header_generation(leaf);
8125
8126         rec->objectid = key->objectid;
8127         rec->type = key->type;
8128         rec->offset = key->offset;
8129
8130         rec->length = rec->cache.size;
8131         rec->owner = btrfs_chunk_owner(leaf, ptr);
8132         rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
8133         rec->type_flags = btrfs_chunk_type(leaf, ptr);
8134         rec->io_width = btrfs_chunk_io_width(leaf, ptr);
8135         rec->io_align = btrfs_chunk_io_align(leaf, ptr);
8136         rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
8137         rec->num_stripes = num_stripes;
8138         rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
8139
8140         for (i = 0; i < rec->num_stripes; ++i) {
8141                 rec->stripes[i].devid =
8142                         btrfs_stripe_devid_nr(leaf, ptr, i);
8143                 rec->stripes[i].offset =
8144                         btrfs_stripe_offset_nr(leaf, ptr, i);
8145                 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
8146                                 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
8147                                 BTRFS_UUID_SIZE);
8148         }
8149
8150         return rec;
8151 }
8152
8153 static int process_chunk_item(struct cache_tree *chunk_cache,
8154                               struct btrfs_key *key, struct extent_buffer *eb,
8155                               int slot)
8156 {
8157         struct chunk_record *rec;
8158         struct btrfs_chunk *chunk;
8159         int ret = 0;
8160
8161         chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
8162         /*
8163          * Do extra check for this chunk item,
8164          *
8165          * It's still possible one can craft a leaf with CHUNK_ITEM, with
8166          * wrong onwer(3) out of chunk tree, to pass both chunk tree check
8167          * and owner<->key_type check.
8168          */
8169         ret = btrfs_check_chunk_valid(global_info, eb, chunk, slot,
8170                                       key->offset);
8171         if (ret < 0) {
8172                 error("chunk(%llu, %llu) is not valid, ignore it",
8173                       key->offset, btrfs_chunk_length(eb, chunk));
8174                 return 0;
8175         }
8176         rec = btrfs_new_chunk_record(eb, key, slot);
8177         ret = insert_cache_extent(chunk_cache, &rec->cache);
8178         if (ret) {
8179                 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
8180                         rec->offset, rec->length);
8181                 free(rec);
8182         }
8183
8184         return ret;
8185 }
8186
8187 static int process_device_item(struct rb_root *dev_cache,
8188                 struct btrfs_key *key, struct extent_buffer *eb, int slot)
8189 {
8190         struct btrfs_dev_item *ptr;
8191         struct device_record *rec;
8192         int ret = 0;
8193
8194         ptr = btrfs_item_ptr(eb,
8195                 slot, struct btrfs_dev_item);
8196
8197         rec = malloc(sizeof(*rec));
8198         if (!rec) {
8199                 fprintf(stderr, "memory allocation failed\n");
8200                 return -ENOMEM;
8201         }
8202
8203         rec->devid = key->offset;
8204         rec->generation = btrfs_header_generation(eb);
8205
8206         rec->objectid = key->objectid;
8207         rec->type = key->type;
8208         rec->offset = key->offset;
8209
8210         rec->devid = btrfs_device_id(eb, ptr);
8211         rec->total_byte = btrfs_device_total_bytes(eb, ptr);
8212         rec->byte_used = btrfs_device_bytes_used(eb, ptr);
8213
8214         ret = rb_insert(dev_cache, &rec->node, device_record_compare);
8215         if (ret) {
8216                 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
8217                 free(rec);
8218         }
8219
8220         return ret;
8221 }
8222
8223 struct block_group_record *
8224 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
8225                              int slot)
8226 {
8227         struct btrfs_block_group_item *ptr;
8228         struct block_group_record *rec;
8229
8230         rec = calloc(1, sizeof(*rec));
8231         if (!rec) {
8232                 fprintf(stderr, "memory allocation failed\n");
8233                 exit(-1);
8234         }
8235
8236         rec->cache.start = key->objectid;
8237         rec->cache.size = key->offset;
8238
8239         rec->generation = btrfs_header_generation(leaf);
8240
8241         rec->objectid = key->objectid;
8242         rec->type = key->type;
8243         rec->offset = key->offset;
8244
8245         ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
8246         rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
8247
8248         INIT_LIST_HEAD(&rec->list);
8249
8250         return rec;
8251 }
8252
8253 static int process_block_group_item(struct block_group_tree *block_group_cache,
8254                                     struct btrfs_key *key,
8255                                     struct extent_buffer *eb, int slot)
8256 {
8257         struct block_group_record *rec;
8258         int ret = 0;
8259
8260         rec = btrfs_new_block_group_record(eb, key, slot);
8261         ret = insert_block_group_record(block_group_cache, rec);
8262         if (ret) {
8263                 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
8264                         rec->objectid, rec->offset);
8265                 free(rec);
8266         }
8267
8268         return ret;
8269 }
8270
8271 struct device_extent_record *
8272 btrfs_new_device_extent_record(struct extent_buffer *leaf,
8273                                struct btrfs_key *key, int slot)
8274 {
8275         struct device_extent_record *rec;
8276         struct btrfs_dev_extent *ptr;
8277
8278         rec = calloc(1, sizeof(*rec));
8279         if (!rec) {
8280                 fprintf(stderr, "memory allocation failed\n");
8281                 exit(-1);
8282         }
8283
8284         rec->cache.objectid = key->objectid;
8285         rec->cache.start = key->offset;
8286
8287         rec->generation = btrfs_header_generation(leaf);
8288
8289         rec->objectid = key->objectid;
8290         rec->type = key->type;
8291         rec->offset = key->offset;
8292
8293         ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
8294         rec->chunk_objecteid =
8295                 btrfs_dev_extent_chunk_objectid(leaf, ptr);
8296         rec->chunk_offset =
8297                 btrfs_dev_extent_chunk_offset(leaf, ptr);
8298         rec->length = btrfs_dev_extent_length(leaf, ptr);
8299         rec->cache.size = rec->length;
8300
8301         INIT_LIST_HEAD(&rec->chunk_list);
8302         INIT_LIST_HEAD(&rec->device_list);
8303
8304         return rec;
8305 }
8306
8307 static int
8308 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
8309                            struct btrfs_key *key, struct extent_buffer *eb,
8310                            int slot)
8311 {
8312         struct device_extent_record *rec;
8313         int ret;
8314
8315         rec = btrfs_new_device_extent_record(eb, key, slot);
8316         ret = insert_device_extent_record(dev_extent_cache, rec);
8317         if (ret) {
8318                 fprintf(stderr,
8319                         "Device extent[%llu, %llu, %llu] existed.\n",
8320                         rec->objectid, rec->offset, rec->length);
8321                 free(rec);
8322         }
8323
8324         return ret;
8325 }
8326
8327 static int process_extent_item(struct btrfs_root *root,
8328                                struct cache_tree *extent_cache,
8329                                struct extent_buffer *eb, int slot)
8330 {
8331         struct btrfs_extent_item *ei;
8332         struct btrfs_extent_inline_ref *iref;
8333         struct btrfs_extent_data_ref *dref;
8334         struct btrfs_shared_data_ref *sref;
8335         struct btrfs_key key;
8336         struct extent_record tmpl;
8337         unsigned long end;
8338         unsigned long ptr;
8339         int ret;
8340         int type;
8341         u32 item_size = btrfs_item_size_nr(eb, slot);
8342         u64 refs = 0;
8343         u64 offset;
8344         u64 num_bytes;
8345         int metadata = 0;
8346
8347         btrfs_item_key_to_cpu(eb, &key, slot);
8348
8349         if (key.type == BTRFS_METADATA_ITEM_KEY) {
8350                 metadata = 1;
8351                 num_bytes = root->fs_info->nodesize;
8352         } else {
8353                 num_bytes = key.offset;
8354         }
8355
8356         if (!IS_ALIGNED(key.objectid, root->fs_info->sectorsize)) {
8357                 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
8358                       key.objectid, root->fs_info->sectorsize);
8359                 return -EIO;
8360         }
8361         if (item_size < sizeof(*ei)) {
8362 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
8363                 struct btrfs_extent_item_v0 *ei0;
8364                 BUG_ON(item_size != sizeof(*ei0));
8365                 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
8366                 refs = btrfs_extent_refs_v0(eb, ei0);
8367 #else
8368                 BUG();
8369 #endif
8370                 memset(&tmpl, 0, sizeof(tmpl));
8371                 tmpl.start = key.objectid;
8372                 tmpl.nr = num_bytes;
8373                 tmpl.extent_item_refs = refs;
8374                 tmpl.metadata = metadata;
8375                 tmpl.found_rec = 1;
8376                 tmpl.max_size = num_bytes;
8377
8378                 return add_extent_rec(extent_cache, &tmpl);
8379         }
8380
8381         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
8382         refs = btrfs_extent_refs(eb, ei);
8383         if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
8384                 metadata = 1;
8385         else
8386                 metadata = 0;
8387         if (metadata && num_bytes != root->fs_info->nodesize) {
8388                 error("ignore invalid metadata extent, length %llu does not equal to %u",
8389                       num_bytes, root->fs_info->nodesize);
8390                 return -EIO;
8391         }
8392         if (!metadata && !IS_ALIGNED(num_bytes, root->fs_info->sectorsize)) {
8393                 error("ignore invalid data extent, length %llu is not aligned to %u",
8394                       num_bytes, root->fs_info->sectorsize);
8395                 return -EIO;
8396         }
8397
8398         memset(&tmpl, 0, sizeof(tmpl));
8399         tmpl.start = key.objectid;
8400         tmpl.nr = num_bytes;
8401         tmpl.extent_item_refs = refs;
8402         tmpl.metadata = metadata;
8403         tmpl.found_rec = 1;
8404         tmpl.max_size = num_bytes;
8405         add_extent_rec(extent_cache, &tmpl);
8406
8407         ptr = (unsigned long)(ei + 1);
8408         if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
8409             key.type == BTRFS_EXTENT_ITEM_KEY)
8410                 ptr += sizeof(struct btrfs_tree_block_info);
8411
8412         end = (unsigned long)ei + item_size;
8413         while (ptr < end) {
8414                 iref = (struct btrfs_extent_inline_ref *)ptr;
8415                 type = btrfs_extent_inline_ref_type(eb, iref);
8416                 offset = btrfs_extent_inline_ref_offset(eb, iref);
8417                 switch (type) {
8418                 case BTRFS_TREE_BLOCK_REF_KEY:
8419                         ret = add_tree_backref(extent_cache, key.objectid,
8420                                         0, offset, 0);
8421                         if (ret < 0)
8422                                 error(
8423                         "add_tree_backref failed (extent items tree block): %s",
8424                                       strerror(-ret));
8425                         break;
8426                 case BTRFS_SHARED_BLOCK_REF_KEY:
8427                         ret = add_tree_backref(extent_cache, key.objectid,
8428                                         offset, 0, 0);
8429                         if (ret < 0)
8430                                 error(
8431                         "add_tree_backref failed (extent items shared block): %s",
8432                                       strerror(-ret));
8433                         break;
8434                 case BTRFS_EXTENT_DATA_REF_KEY:
8435                         dref = (struct btrfs_extent_data_ref *)(&iref->offset);
8436                         add_data_backref(extent_cache, key.objectid, 0,
8437                                         btrfs_extent_data_ref_root(eb, dref),
8438                                         btrfs_extent_data_ref_objectid(eb,
8439                                                                        dref),
8440                                         btrfs_extent_data_ref_offset(eb, dref),
8441                                         btrfs_extent_data_ref_count(eb, dref),
8442                                         0, num_bytes);
8443                         break;
8444                 case BTRFS_SHARED_DATA_REF_KEY:
8445                         sref = (struct btrfs_shared_data_ref *)(iref + 1);
8446                         add_data_backref(extent_cache, key.objectid, offset,
8447                                         0, 0, 0,
8448                                         btrfs_shared_data_ref_count(eb, sref),
8449                                         0, num_bytes);
8450                         break;
8451                 default:
8452                         fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
8453                                 key.objectid, key.type, num_bytes);
8454                         goto out;
8455                 }
8456                 ptr += btrfs_extent_inline_ref_size(type);
8457         }
8458         WARN_ON(ptr > end);
8459 out:
8460         return 0;
8461 }
8462
8463 static int check_cache_range(struct btrfs_root *root,
8464                              struct btrfs_block_group_cache *cache,
8465                              u64 offset, u64 bytes)
8466 {
8467         struct btrfs_free_space *entry;
8468         u64 *logical;
8469         u64 bytenr;
8470         int stripe_len;
8471         int i, nr, ret;
8472
8473         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
8474                 bytenr = btrfs_sb_offset(i);
8475                 ret = btrfs_rmap_block(root->fs_info,
8476                                        cache->key.objectid, bytenr, 0,
8477                                        &logical, &nr, &stripe_len);
8478                 if (ret)
8479                         return ret;
8480
8481                 while (nr--) {
8482                         if (logical[nr] + stripe_len <= offset)
8483                                 continue;
8484                         if (offset + bytes <= logical[nr])
8485                                 continue;
8486                         if (logical[nr] == offset) {
8487                                 if (stripe_len >= bytes) {
8488                                         free(logical);
8489                                         return 0;
8490                                 }
8491                                 bytes -= stripe_len;
8492                                 offset += stripe_len;
8493                         } else if (logical[nr] < offset) {
8494                                 if (logical[nr] + stripe_len >=
8495                                     offset + bytes) {
8496                                         free(logical);
8497                                         return 0;
8498                                 }
8499                                 bytes = (offset + bytes) -
8500                                         (logical[nr] + stripe_len);
8501                                 offset = logical[nr] + stripe_len;
8502                         } else {
8503                                 /*
8504                                  * Could be tricky, the super may land in the
8505                                  * middle of the area we're checking.  First
8506                                  * check the easiest case, it's at the end.
8507                                  */
8508                                 if (logical[nr] + stripe_len >=
8509                                     bytes + offset) {
8510                                         bytes = logical[nr] - offset;
8511                                         continue;
8512                                 }
8513
8514                                 /* Check the left side */
8515                                 ret = check_cache_range(root, cache,
8516                                                         offset,
8517                                                         logical[nr] - offset);
8518                                 if (ret) {
8519                                         free(logical);
8520                                         return ret;
8521                                 }
8522
8523                                 /* Now we continue with the right side */
8524                                 bytes = (offset + bytes) -
8525                                         (logical[nr] + stripe_len);
8526                                 offset = logical[nr] + stripe_len;
8527                         }
8528                 }
8529
8530                 free(logical);
8531         }
8532
8533         entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
8534         if (!entry) {
8535                 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
8536                         offset, offset+bytes);
8537                 return -EINVAL;
8538         }
8539
8540         if (entry->offset != offset) {
8541                 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
8542                         entry->offset);
8543                 return -EINVAL;
8544         }
8545
8546         if (entry->bytes != bytes) {
8547                 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
8548                         bytes, entry->bytes, offset);
8549                 return -EINVAL;
8550         }
8551
8552         unlink_free_space(cache->free_space_ctl, entry);
8553         free(entry);
8554         return 0;
8555 }
8556
8557 static int verify_space_cache(struct btrfs_root *root,
8558                               struct btrfs_block_group_cache *cache)
8559 {
8560         struct btrfs_path path;
8561         struct extent_buffer *leaf;
8562         struct btrfs_key key;
8563         u64 last;
8564         int ret = 0;
8565
8566         root = root->fs_info->extent_root;
8567
8568         last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
8569
8570         btrfs_init_path(&path);
8571         key.objectid = last;
8572         key.offset = 0;
8573         key.type = BTRFS_EXTENT_ITEM_KEY;
8574         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
8575         if (ret < 0)
8576                 goto out;
8577         ret = 0;
8578         while (1) {
8579                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
8580                         ret = btrfs_next_leaf(root, &path);
8581                         if (ret < 0)
8582                                 goto out;
8583                         if (ret > 0) {
8584                                 ret = 0;
8585                                 break;
8586                         }
8587                 }
8588                 leaf = path.nodes[0];
8589                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
8590                 if (key.objectid >= cache->key.offset + cache->key.objectid)
8591                         break;
8592                 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
8593                     key.type != BTRFS_METADATA_ITEM_KEY) {
8594                         path.slots[0]++;
8595                         continue;
8596                 }
8597
8598                 if (last == key.objectid) {
8599                         if (key.type == BTRFS_EXTENT_ITEM_KEY)
8600                                 last = key.objectid + key.offset;
8601                         else
8602                                 last = key.objectid + root->fs_info->nodesize;
8603                         path.slots[0]++;
8604                         continue;
8605                 }
8606
8607                 ret = check_cache_range(root, cache, last,
8608                                         key.objectid - last);
8609                 if (ret)
8610                         break;
8611                 if (key.type == BTRFS_EXTENT_ITEM_KEY)
8612                         last = key.objectid + key.offset;
8613                 else
8614                         last = key.objectid + root->fs_info->nodesize;
8615                 path.slots[0]++;
8616         }
8617
8618         if (last < cache->key.objectid + cache->key.offset)
8619                 ret = check_cache_range(root, cache, last,
8620                                         cache->key.objectid +
8621                                         cache->key.offset - last);
8622
8623 out:
8624         btrfs_release_path(&path);
8625
8626         if (!ret &&
8627             !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
8628                 fprintf(stderr, "There are still entries left in the space "
8629                         "cache\n");
8630                 ret = -EINVAL;
8631         }
8632
8633         return ret;
8634 }
8635
8636 static int check_space_cache(struct btrfs_root *root)
8637 {
8638         struct btrfs_block_group_cache *cache;
8639         u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
8640         int ret;
8641         int error = 0;
8642
8643         if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
8644             btrfs_super_generation(root->fs_info->super_copy) !=
8645             btrfs_super_cache_generation(root->fs_info->super_copy)) {
8646                 printf("cache and super generation don't match, space cache "
8647                        "will be invalidated\n");
8648                 return 0;
8649         }
8650
8651         if (ctx.progress_enabled) {
8652                 ctx.tp = TASK_FREE_SPACE;
8653                 task_start(ctx.info);
8654         }
8655
8656         while (1) {
8657                 cache = btrfs_lookup_first_block_group(root->fs_info, start);
8658                 if (!cache)
8659                         break;
8660
8661                 start = cache->key.objectid + cache->key.offset;
8662                 if (!cache->free_space_ctl) {
8663                         if (btrfs_init_free_space_ctl(cache,
8664                                                 root->fs_info->sectorsize)) {
8665                                 ret = -ENOMEM;
8666                                 break;
8667                         }
8668                 } else {
8669                         btrfs_remove_free_space_cache(cache);
8670                 }
8671
8672                 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
8673                         ret = exclude_super_stripes(root, cache);
8674                         if (ret) {
8675                                 fprintf(stderr, "could not exclude super stripes: %s\n",
8676                                         strerror(-ret));
8677                                 error++;
8678                                 continue;
8679                         }
8680                         ret = load_free_space_tree(root->fs_info, cache);
8681                         free_excluded_extents(root, cache);
8682                         if (ret < 0) {
8683                                 fprintf(stderr, "could not load free space tree: %s\n",
8684                                         strerror(-ret));
8685                                 error++;
8686                                 continue;
8687                         }
8688                         error += ret;
8689                 } else {
8690                         ret = load_free_space_cache(root->fs_info, cache);
8691                         if (!ret)
8692                                 continue;
8693                 }
8694
8695                 ret = verify_space_cache(root, cache);
8696                 if (ret) {
8697                         fprintf(stderr, "cache appears valid but isn't %Lu\n",
8698                                 cache->key.objectid);
8699                         error++;
8700                 }
8701         }
8702
8703         task_stop(ctx.info);
8704
8705         return error ? -EINVAL : 0;
8706 }
8707
8708 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
8709                         u64 num_bytes, unsigned long leaf_offset,
8710                         struct extent_buffer *eb) {
8711
8712         struct btrfs_fs_info *fs_info = root->fs_info;
8713         u64 offset = 0;
8714         u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
8715         char *data;
8716         unsigned long csum_offset;
8717         u32 csum;
8718         u32 csum_expected;
8719         u64 read_len;
8720         u64 data_checked = 0;
8721         u64 tmp;
8722         int ret = 0;
8723         int mirror;
8724         int num_copies;
8725
8726         if (num_bytes % fs_info->sectorsize)
8727                 return -EINVAL;
8728
8729         data = malloc(num_bytes);
8730         if (!data)
8731                 return -ENOMEM;
8732
8733         while (offset < num_bytes) {
8734                 mirror = 0;
8735 again:
8736                 read_len = num_bytes - offset;
8737                 /* read as much space once a time */
8738                 ret = read_extent_data(fs_info, data + offset,
8739                                 bytenr + offset, &read_len, mirror);
8740                 if (ret)
8741                         goto out;
8742                 data_checked = 0;
8743                 /* verify every 4k data's checksum */
8744                 while (data_checked < read_len) {
8745                         csum = ~(u32)0;
8746                         tmp = offset + data_checked;
8747
8748                         csum = btrfs_csum_data((char *)data + tmp,
8749                                                csum, fs_info->sectorsize);
8750                         btrfs_csum_final(csum, (u8 *)&csum);
8751
8752                         csum_offset = leaf_offset +
8753                                  tmp / fs_info->sectorsize * csum_size;
8754                         read_extent_buffer(eb, (char *)&csum_expected,
8755                                            csum_offset, csum_size);
8756                         /* try another mirror */
8757                         if (csum != csum_expected) {
8758                                 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
8759                                                 mirror, bytenr + tmp,
8760                                                 csum, csum_expected);
8761                                 num_copies = btrfs_num_copies(root->fs_info,
8762                                                 bytenr, num_bytes);
8763                                 if (mirror < num_copies - 1) {
8764                                         mirror += 1;
8765                                         goto again;
8766                                 }
8767                         }
8768                         data_checked += fs_info->sectorsize;
8769                 }
8770                 offset += read_len;
8771         }
8772 out:
8773         free(data);
8774         return ret;
8775 }
8776
8777 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
8778                                u64 num_bytes)
8779 {
8780         struct btrfs_path path;
8781         struct extent_buffer *leaf;
8782         struct btrfs_key key;
8783         int ret;
8784
8785         btrfs_init_path(&path);
8786         key.objectid = bytenr;
8787         key.type = BTRFS_EXTENT_ITEM_KEY;
8788         key.offset = (u64)-1;
8789
8790 again:
8791         ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
8792                                 0, 0);
8793         if (ret < 0) {
8794                 fprintf(stderr, "Error looking up extent record %d\n", ret);
8795                 btrfs_release_path(&path);
8796                 return ret;
8797         } else if (ret) {
8798                 if (path.slots[0] > 0) {
8799                         path.slots[0]--;
8800                 } else {
8801                         ret = btrfs_prev_leaf(root, &path);
8802                         if (ret < 0) {
8803                                 goto out;
8804                         } else if (ret > 0) {
8805                                 ret = 0;
8806                                 goto out;
8807                         }
8808                 }
8809         }
8810
8811         btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
8812
8813         /*
8814          * Block group items come before extent items if they have the same
8815          * bytenr, so walk back one more just in case.  Dear future traveller,
8816          * first congrats on mastering time travel.  Now if it's not too much
8817          * trouble could you go back to 2006 and tell Chris to make the
8818          * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
8819          * EXTENT_ITEM_KEY please?
8820          */
8821         while (key.type > BTRFS_EXTENT_ITEM_KEY) {
8822                 if (path.slots[0] > 0) {
8823                         path.slots[0]--;
8824                 } else {
8825                         ret = btrfs_prev_leaf(root, &path);
8826                         if (ret < 0) {
8827                                 goto out;
8828                         } else if (ret > 0) {
8829                                 ret = 0;
8830                                 goto out;
8831                         }
8832                 }
8833                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
8834         }
8835
8836         while (num_bytes) {
8837                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
8838                         ret = btrfs_next_leaf(root, &path);
8839                         if (ret < 0) {
8840                                 fprintf(stderr, "Error going to next leaf "
8841                                         "%d\n", ret);
8842                                 btrfs_release_path(&path);
8843                                 return ret;
8844                         } else if (ret) {
8845                                 break;
8846                         }
8847                 }
8848                 leaf = path.nodes[0];
8849                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
8850                 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
8851                         path.slots[0]++;
8852                         continue;
8853                 }
8854                 if (key.objectid + key.offset < bytenr) {
8855                         path.slots[0]++;
8856                         continue;
8857                 }
8858                 if (key.objectid > bytenr + num_bytes)
8859                         break;
8860
8861                 if (key.objectid == bytenr) {
8862                         if (key.offset >= num_bytes) {
8863                                 num_bytes = 0;
8864                                 break;
8865                         }
8866                         num_bytes -= key.offset;
8867                         bytenr += key.offset;
8868                 } else if (key.objectid < bytenr) {
8869                         if (key.objectid + key.offset >= bytenr + num_bytes) {
8870                                 num_bytes = 0;
8871                                 break;
8872                         }
8873                         num_bytes = (bytenr + num_bytes) -
8874                                 (key.objectid + key.offset);
8875                         bytenr = key.objectid + key.offset;
8876                 } else {
8877                         if (key.objectid + key.offset < bytenr + num_bytes) {
8878                                 u64 new_start = key.objectid + key.offset;
8879                                 u64 new_bytes = bytenr + num_bytes - new_start;
8880
8881                                 /*
8882                                  * Weird case, the extent is in the middle of
8883                                  * our range, we'll have to search one side
8884                                  * and then the other.  Not sure if this happens
8885                                  * in real life, but no harm in coding it up
8886                                  * anyway just in case.
8887                                  */
8888                                 btrfs_release_path(&path);
8889                                 ret = check_extent_exists(root, new_start,
8890                                                           new_bytes);
8891                                 if (ret) {
8892                                         fprintf(stderr, "Right section didn't "
8893                                                 "have a record\n");
8894                                         break;
8895                                 }
8896                                 num_bytes = key.objectid - bytenr;
8897                                 goto again;
8898                         }
8899                         num_bytes = key.objectid - bytenr;
8900                 }
8901                 path.slots[0]++;
8902         }
8903         ret = 0;
8904
8905 out:
8906         if (num_bytes && !ret) {
8907                 fprintf(stderr, "There are no extents for csum range "
8908                         "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
8909                 ret = 1;
8910         }
8911
8912         btrfs_release_path(&path);
8913         return ret;
8914 }
8915
8916 static int check_csums(struct btrfs_root *root)
8917 {
8918         struct btrfs_path path;
8919         struct extent_buffer *leaf;
8920         struct btrfs_key key;
8921         u64 offset = 0, num_bytes = 0;
8922         u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
8923         int errors = 0;
8924         int ret;
8925         u64 data_len;
8926         unsigned long leaf_offset;
8927
8928         root = root->fs_info->csum_root;
8929         if (!extent_buffer_uptodate(root->node)) {
8930                 fprintf(stderr, "No valid csum tree found\n");
8931                 return -ENOENT;
8932         }
8933
8934         btrfs_init_path(&path);
8935         key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
8936         key.type = BTRFS_EXTENT_CSUM_KEY;
8937         key.offset = 0;
8938         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
8939         if (ret < 0) {
8940                 fprintf(stderr, "Error searching csum tree %d\n", ret);
8941                 btrfs_release_path(&path);
8942                 return ret;
8943         }
8944
8945         if (ret > 0 && path.slots[0])
8946                 path.slots[0]--;
8947         ret = 0;
8948
8949         while (1) {
8950                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
8951                         ret = btrfs_next_leaf(root, &path);
8952                         if (ret < 0) {
8953                                 fprintf(stderr, "Error going to next leaf "
8954                                         "%d\n", ret);
8955                                 break;
8956                         }
8957                         if (ret)
8958                                 break;
8959                 }
8960                 leaf = path.nodes[0];
8961
8962                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
8963                 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
8964                         path.slots[0]++;
8965                         continue;
8966                 }
8967
8968                 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
8969                               csum_size) * root->fs_info->sectorsize;
8970                 if (!check_data_csum)
8971                         goto skip_csum_check;
8972                 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
8973                 ret = check_extent_csums(root, key.offset, data_len,
8974                                          leaf_offset, leaf);
8975                 if (ret)
8976                         break;
8977 skip_csum_check:
8978                 if (!num_bytes) {
8979                         offset = key.offset;
8980                 } else if (key.offset != offset + num_bytes) {
8981                         ret = check_extent_exists(root, offset, num_bytes);
8982                         if (ret) {
8983                                 fprintf(stderr, "Csum exists for %Lu-%Lu but "
8984                                         "there is no extent record\n",
8985                                         offset, offset+num_bytes);
8986                                 errors++;
8987                         }
8988                         offset = key.offset;
8989                         num_bytes = 0;
8990                 }
8991                 num_bytes += data_len;
8992                 path.slots[0]++;
8993         }
8994
8995         btrfs_release_path(&path);
8996         return errors;
8997 }
8998
8999 static int is_dropped_key(struct btrfs_key *key,
9000                           struct btrfs_key *drop_key) {
9001         if (key->objectid < drop_key->objectid)
9002                 return 1;
9003         else if (key->objectid == drop_key->objectid) {
9004                 if (key->type < drop_key->type)
9005                         return 1;
9006                 else if (key->type == drop_key->type) {
9007                         if (key->offset < drop_key->offset)
9008                                 return 1;
9009                 }
9010         }
9011         return 0;
9012 }
9013
9014 /*
9015  * Here are the rules for FULL_BACKREF.
9016  *
9017  * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
9018  * 2) If btrfs_header_owner(buf) no longer points to buf then we have
9019  *      FULL_BACKREF set.
9020  * 3) We cowed the block walking down a reloc tree.  This is impossible to tell
9021  *    if it happened after the relocation occurred since we'll have dropped the
9022  *    reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
9023  *    have no real way to know for sure.
9024  *
9025  * We process the blocks one root at a time, and we start from the lowest root
9026  * objectid and go to the highest.  So we can just lookup the owner backref for
9027  * the record and if we don't find it then we know it doesn't exist and we have
9028  * a FULL BACKREF.
9029  *
9030  * FIXME: if we ever start reclaiming root objectid's then we need to fix this
9031  * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
9032  * be set or not and then we can check later once we've gathered all the refs.
9033  */
9034 static int calc_extent_flag(struct cache_tree *extent_cache,
9035                            struct extent_buffer *buf,
9036                            struct root_item_record *ri,
9037                            u64 *flags)
9038 {
9039         struct extent_record *rec;
9040         struct cache_extent *cache;
9041         struct tree_backref *tback;
9042         u64 owner = 0;
9043
9044         cache = lookup_cache_extent(extent_cache, buf->start, 1);
9045         /* we have added this extent before */
9046         if (!cache)
9047                 return -ENOENT;
9048
9049         rec = container_of(cache, struct extent_record, cache);
9050
9051         /*
9052          * Except file/reloc tree, we can not have
9053          * FULL BACKREF MODE
9054          */
9055         if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
9056                 goto normal;
9057         /*
9058          * root node
9059          */
9060         if (buf->start == ri->bytenr)
9061                 goto normal;
9062
9063         if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
9064                 goto full_backref;
9065
9066         owner = btrfs_header_owner(buf);
9067         if (owner == ri->objectid)
9068                 goto normal;
9069
9070         tback = find_tree_backref(rec, 0, owner);
9071         if (!tback)
9072                 goto full_backref;
9073 normal:
9074         *flags = 0;
9075         if (rec->flag_block_full_backref != FLAG_UNSET &&
9076             rec->flag_block_full_backref != 0)
9077                 rec->bad_full_backref = 1;
9078         return 0;
9079 full_backref:
9080         *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9081         if (rec->flag_block_full_backref != FLAG_UNSET &&
9082             rec->flag_block_full_backref != 1)
9083                 rec->bad_full_backref = 1;
9084         return 0;
9085 }
9086
9087 static void report_mismatch_key_root(u8 key_type, u64 rootid)
9088 {
9089         fprintf(stderr, "Invalid key type(");
9090         print_key_type(stderr, 0, key_type);
9091         fprintf(stderr, ") found in root(");
9092         print_objectid(stderr, rootid, 0);
9093         fprintf(stderr, ")\n");
9094 }
9095
9096 /*
9097  * Check if the key is valid with its extent buffer.
9098  *
9099  * This is a early check in case invalid key exists in a extent buffer
9100  * This is not comprehensive yet, but should prevent wrong key/item passed
9101  * further
9102  */
9103 static int check_type_with_root(u64 rootid, u8 key_type)
9104 {
9105         switch (key_type) {
9106         /* Only valid in chunk tree */
9107         case BTRFS_DEV_ITEM_KEY:
9108         case BTRFS_CHUNK_ITEM_KEY:
9109                 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
9110                         goto err;
9111                 break;
9112         /* valid in csum and log tree */
9113         case BTRFS_CSUM_TREE_OBJECTID:
9114                 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
9115                       is_fstree(rootid)))
9116                         goto err;
9117                 break;
9118         case BTRFS_EXTENT_ITEM_KEY:
9119         case BTRFS_METADATA_ITEM_KEY:
9120         case BTRFS_BLOCK_GROUP_ITEM_KEY:
9121                 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
9122                         goto err;
9123                 break;
9124         case BTRFS_ROOT_ITEM_KEY:
9125                 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
9126                         goto err;
9127                 break;
9128         case BTRFS_DEV_EXTENT_KEY:
9129                 if (rootid != BTRFS_DEV_TREE_OBJECTID)
9130                         goto err;
9131                 break;
9132         }
9133         return 0;
9134 err:
9135         report_mismatch_key_root(key_type, rootid);
9136         return -EINVAL;
9137 }
9138
9139 static int run_next_block(struct btrfs_root *root,
9140                           struct block_info *bits,
9141                           int bits_nr,
9142                           u64 *last,
9143                           struct cache_tree *pending,
9144                           struct cache_tree *seen,
9145                           struct cache_tree *reada,
9146                           struct cache_tree *nodes,
9147                           struct cache_tree *extent_cache,
9148                           struct cache_tree *chunk_cache,
9149                           struct rb_root *dev_cache,
9150                           struct block_group_tree *block_group_cache,
9151                           struct device_extent_tree *dev_extent_cache,
9152                           struct root_item_record *ri)
9153 {
9154         struct btrfs_fs_info *fs_info = root->fs_info;
9155         struct extent_buffer *buf;
9156         struct extent_record *rec = NULL;
9157         u64 bytenr;
9158         u32 size;
9159         u64 parent;
9160         u64 owner;
9161         u64 flags;
9162         u64 ptr;
9163         u64 gen = 0;
9164         int ret = 0;
9165         int i;
9166         int nritems;
9167         struct btrfs_key key;
9168         struct cache_extent *cache;
9169         int reada_bits;
9170
9171         nritems = pick_next_pending(pending, reada, nodes, *last, bits,
9172                                     bits_nr, &reada_bits);
9173         if (nritems == 0)
9174                 return 1;
9175
9176         if (!reada_bits) {
9177                 for(i = 0; i < nritems; i++) {
9178                         ret = add_cache_extent(reada, bits[i].start,
9179                                                bits[i].size);
9180                         if (ret == -EEXIST)
9181                                 continue;
9182
9183                         /* fixme, get the parent transid */
9184                         readahead_tree_block(fs_info, bits[i].start, 0);
9185                 }
9186         }
9187         *last = bits[0].start;
9188         bytenr = bits[0].start;
9189         size = bits[0].size;
9190
9191         cache = lookup_cache_extent(pending, bytenr, size);
9192         if (cache) {
9193                 remove_cache_extent(pending, cache);
9194                 free(cache);
9195         }
9196         cache = lookup_cache_extent(reada, bytenr, size);
9197         if (cache) {
9198                 remove_cache_extent(reada, cache);
9199                 free(cache);
9200         }
9201         cache = lookup_cache_extent(nodes, bytenr, size);
9202         if (cache) {
9203                 remove_cache_extent(nodes, cache);
9204                 free(cache);
9205         }
9206         cache = lookup_cache_extent(extent_cache, bytenr, size);
9207         if (cache) {
9208                 rec = container_of(cache, struct extent_record, cache);
9209                 gen = rec->parent_generation;
9210         }
9211
9212         /* fixme, get the real parent transid */
9213         buf = read_tree_block(root->fs_info, bytenr, gen);
9214         if (!extent_buffer_uptodate(buf)) {
9215                 record_bad_block_io(root->fs_info,
9216                                     extent_cache, bytenr, size);
9217                 goto out;
9218         }
9219
9220         nritems = btrfs_header_nritems(buf);
9221
9222         flags = 0;
9223         if (!init_extent_tree) {
9224                 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
9225                                        btrfs_header_level(buf), 1, NULL,
9226                                        &flags);
9227                 if (ret < 0) {
9228                         ret = calc_extent_flag(extent_cache, buf, ri, &flags);
9229                         if (ret < 0) {
9230                                 fprintf(stderr, "Couldn't calc extent flags\n");
9231                                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9232                         }
9233                 }
9234         } else {
9235                 flags = 0;
9236                 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
9237                 if (ret < 0) {
9238                         fprintf(stderr, "Couldn't calc extent flags\n");
9239                         flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9240                 }
9241         }
9242
9243         if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
9244                 if (ri != NULL &&
9245                     ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
9246                     ri->objectid == btrfs_header_owner(buf)) {
9247                         /*
9248                          * Ok we got to this block from it's original owner and
9249                          * we have FULL_BACKREF set.  Relocation can leave
9250                          * converted blocks over so this is altogether possible,
9251                          * however it's not possible if the generation > the
9252                          * last snapshot, so check for this case.
9253                          */
9254                         if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
9255                             btrfs_header_generation(buf) > ri->last_snapshot) {
9256                                 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9257                                 rec->bad_full_backref = 1;
9258                         }
9259                 }
9260         } else {
9261                 if (ri != NULL &&
9262                     (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
9263                      btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
9264                         flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9265                         rec->bad_full_backref = 1;
9266                 }
9267         }
9268
9269         if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
9270                 rec->flag_block_full_backref = 1;
9271                 parent = bytenr;
9272                 owner = 0;
9273         } else {
9274                 rec->flag_block_full_backref = 0;
9275                 parent = 0;
9276                 owner = btrfs_header_owner(buf);
9277         }
9278
9279         ret = check_block(root, extent_cache, buf, flags);
9280         if (ret)
9281                 goto out;
9282
9283         if (btrfs_is_leaf(buf)) {
9284                 btree_space_waste += btrfs_leaf_free_space(root, buf);
9285                 for (i = 0; i < nritems; i++) {
9286                         struct btrfs_file_extent_item *fi;
9287                         btrfs_item_key_to_cpu(buf, &key, i);
9288                         /*
9289                          * Check key type against the leaf owner.
9290                          * Could filter quite a lot of early error if
9291                          * owner is correct
9292                          */
9293                         if (check_type_with_root(btrfs_header_owner(buf),
9294                                                  key.type)) {
9295                                 fprintf(stderr, "ignoring invalid key\n");
9296                                 continue;
9297                         }
9298                         if (key.type == BTRFS_EXTENT_ITEM_KEY) {
9299                                 process_extent_item(root, extent_cache, buf,
9300                                                     i);
9301                                 continue;
9302                         }
9303                         if (key.type == BTRFS_METADATA_ITEM_KEY) {
9304                                 process_extent_item(root, extent_cache, buf,
9305                                                     i);
9306                                 continue;
9307                         }
9308                         if (key.type == BTRFS_EXTENT_CSUM_KEY) {
9309                                 total_csum_bytes +=
9310                                         btrfs_item_size_nr(buf, i);
9311                                 continue;
9312                         }
9313                         if (key.type == BTRFS_CHUNK_ITEM_KEY) {
9314                                 process_chunk_item(chunk_cache, &key, buf, i);
9315                                 continue;
9316                         }
9317                         if (key.type == BTRFS_DEV_ITEM_KEY) {
9318                                 process_device_item(dev_cache, &key, buf, i);
9319                                 continue;
9320                         }
9321                         if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
9322                                 process_block_group_item(block_group_cache,
9323                                         &key, buf, i);
9324                                 continue;
9325                         }
9326                         if (key.type == BTRFS_DEV_EXTENT_KEY) {
9327                                 process_device_extent_item(dev_extent_cache,
9328                                         &key, buf, i);
9329                                 continue;
9330
9331                         }
9332                         if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
9333 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
9334                                 process_extent_ref_v0(extent_cache, buf, i);
9335 #else
9336                                 BUG();
9337 #endif
9338                                 continue;
9339                         }
9340
9341                         if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
9342                                 ret = add_tree_backref(extent_cache,
9343                                                 key.objectid, 0, key.offset, 0);
9344                                 if (ret < 0)
9345                                         error(
9346                                 "add_tree_backref failed (leaf tree block): %s",
9347                                               strerror(-ret));
9348                                 continue;
9349                         }
9350                         if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
9351                                 ret = add_tree_backref(extent_cache,
9352                                                 key.objectid, key.offset, 0, 0);
9353                                 if (ret < 0)
9354                                         error(
9355                                 "add_tree_backref failed (leaf shared block): %s",
9356                                               strerror(-ret));
9357                                 continue;
9358                         }
9359                         if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
9360                                 struct btrfs_extent_data_ref *ref;
9361                                 ref = btrfs_item_ptr(buf, i,
9362                                                 struct btrfs_extent_data_ref);
9363                                 add_data_backref(extent_cache,
9364                                         key.objectid, 0,
9365                                         btrfs_extent_data_ref_root(buf, ref),
9366                                         btrfs_extent_data_ref_objectid(buf,
9367                                                                        ref),
9368                                         btrfs_extent_data_ref_offset(buf, ref),
9369                                         btrfs_extent_data_ref_count(buf, ref),
9370                                         0, root->fs_info->sectorsize);
9371                                 continue;
9372                         }
9373                         if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
9374                                 struct btrfs_shared_data_ref *ref;
9375                                 ref = btrfs_item_ptr(buf, i,
9376                                                 struct btrfs_shared_data_ref);
9377                                 add_data_backref(extent_cache,
9378                                         key.objectid, key.offset, 0, 0, 0,
9379                                         btrfs_shared_data_ref_count(buf, ref),
9380                                         0, root->fs_info->sectorsize);
9381                                 continue;
9382                         }
9383                         if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
9384                                 struct bad_item *bad;
9385
9386                                 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
9387                                         continue;
9388                                 if (!owner)
9389                                         continue;
9390                                 bad = malloc(sizeof(struct bad_item));
9391                                 if (!bad)
9392                                         continue;
9393                                 INIT_LIST_HEAD(&bad->list);
9394                                 memcpy(&bad->key, &key,
9395                                        sizeof(struct btrfs_key));
9396                                 bad->root_id = owner;
9397                                 list_add_tail(&bad->list, &delete_items);
9398                                 continue;
9399                         }
9400                         if (key.type != BTRFS_EXTENT_DATA_KEY)
9401                                 continue;
9402                         fi = btrfs_item_ptr(buf, i,
9403                                             struct btrfs_file_extent_item);
9404                         if (btrfs_file_extent_type(buf, fi) ==
9405                             BTRFS_FILE_EXTENT_INLINE)
9406                                 continue;
9407                         if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
9408                                 continue;
9409
9410                         data_bytes_allocated +=
9411                                 btrfs_file_extent_disk_num_bytes(buf, fi);
9412                         if (data_bytes_allocated < root->fs_info->sectorsize) {
9413                                 abort();
9414                         }
9415                         data_bytes_referenced +=
9416                                 btrfs_file_extent_num_bytes(buf, fi);
9417                         add_data_backref(extent_cache,
9418                                 btrfs_file_extent_disk_bytenr(buf, fi),
9419                                 parent, owner, key.objectid, key.offset -
9420                                 btrfs_file_extent_offset(buf, fi), 1, 1,
9421                                 btrfs_file_extent_disk_num_bytes(buf, fi));
9422                 }
9423         } else {
9424                 int level;
9425                 struct btrfs_key first_key;
9426
9427                 first_key.objectid = 0;
9428
9429                 if (nritems > 0)
9430                         btrfs_item_key_to_cpu(buf, &first_key, 0);
9431                 level = btrfs_header_level(buf);
9432                 for (i = 0; i < nritems; i++) {
9433                         struct extent_record tmpl;
9434
9435                         ptr = btrfs_node_blockptr(buf, i);
9436                         size = root->fs_info->nodesize;
9437                         btrfs_node_key_to_cpu(buf, &key, i);
9438                         if (ri != NULL) {
9439                                 if ((level == ri->drop_level)
9440                                     && is_dropped_key(&key, &ri->drop_key)) {
9441                                         continue;
9442                                 }
9443                         }
9444
9445                         memset(&tmpl, 0, sizeof(tmpl));
9446                         btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
9447                         tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
9448                         tmpl.start = ptr;
9449                         tmpl.nr = size;
9450                         tmpl.refs = 1;
9451                         tmpl.metadata = 1;
9452                         tmpl.max_size = size;
9453                         ret = add_extent_rec(extent_cache, &tmpl);
9454                         if (ret < 0)
9455                                 goto out;
9456
9457                         ret = add_tree_backref(extent_cache, ptr, parent,
9458                                         owner, 1);
9459                         if (ret < 0) {
9460                                 error(
9461                                 "add_tree_backref failed (non-leaf block): %s",
9462                                       strerror(-ret));
9463                                 continue;
9464                         }
9465
9466                         if (level > 1) {
9467                                 add_pending(nodes, seen, ptr, size);
9468                         } else {
9469                                 add_pending(pending, seen, ptr, size);
9470                         }
9471                 }
9472                 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
9473                                       nritems) * sizeof(struct btrfs_key_ptr);
9474         }
9475         total_btree_bytes += buf->len;
9476         if (fs_root_objectid(btrfs_header_owner(buf)))
9477                 total_fs_tree_bytes += buf->len;
9478         if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
9479                 total_extent_tree_bytes += buf->len;
9480 out:
9481         free_extent_buffer(buf);
9482         return ret;
9483 }
9484
9485 static int add_root_to_pending(struct extent_buffer *buf,
9486                                struct cache_tree *extent_cache,
9487                                struct cache_tree *pending,
9488                                struct cache_tree *seen,
9489                                struct cache_tree *nodes,
9490                                u64 objectid)
9491 {
9492         struct extent_record tmpl;
9493         int ret;
9494
9495         if (btrfs_header_level(buf) > 0)
9496                 add_pending(nodes, seen, buf->start, buf->len);
9497         else
9498                 add_pending(pending, seen, buf->start, buf->len);
9499
9500         memset(&tmpl, 0, sizeof(tmpl));
9501         tmpl.start = buf->start;
9502         tmpl.nr = buf->len;
9503         tmpl.is_root = 1;
9504         tmpl.refs = 1;
9505         tmpl.metadata = 1;
9506         tmpl.max_size = buf->len;
9507         add_extent_rec(extent_cache, &tmpl);
9508
9509         if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
9510             btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
9511                 ret = add_tree_backref(extent_cache, buf->start, buf->start,
9512                                 0, 1);
9513         else
9514                 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
9515                                 1);
9516         return ret;
9517 }
9518
9519 /* as we fix the tree, we might be deleting blocks that
9520  * we're tracking for repair.  This hook makes sure we
9521  * remove any backrefs for blocks as we are fixing them.
9522  */
9523 static int free_extent_hook(struct btrfs_trans_handle *trans,
9524                             struct btrfs_root *root,
9525                             u64 bytenr, u64 num_bytes, u64 parent,
9526                             u64 root_objectid, u64 owner, u64 offset,
9527                             int refs_to_drop)
9528 {
9529         struct extent_record *rec;
9530         struct cache_extent *cache;
9531         int is_data;
9532         struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
9533
9534         is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
9535         cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
9536         if (!cache)
9537                 return 0;
9538
9539         rec = container_of(cache, struct extent_record, cache);
9540         if (is_data) {
9541                 struct data_backref *back;
9542                 back = find_data_backref(rec, parent, root_objectid, owner,
9543                                          offset, 1, bytenr, num_bytes);
9544                 if (!back)
9545                         goto out;
9546                 if (back->node.found_ref) {
9547                         back->found_ref -= refs_to_drop;
9548                         if (rec->refs)
9549                                 rec->refs -= refs_to_drop;
9550                 }
9551                 if (back->node.found_extent_tree) {
9552                         back->num_refs -= refs_to_drop;
9553                         if (rec->extent_item_refs)
9554                                 rec->extent_item_refs -= refs_to_drop;
9555                 }
9556                 if (back->found_ref == 0)
9557                         back->node.found_ref = 0;
9558                 if (back->num_refs == 0)
9559                         back->node.found_extent_tree = 0;
9560
9561                 if (!back->node.found_extent_tree && back->node.found_ref) {
9562                         rb_erase(&back->node.node, &rec->backref_tree);
9563                         free(back);
9564                 }
9565         } else {
9566                 struct tree_backref *back;
9567                 back = find_tree_backref(rec, parent, root_objectid);
9568                 if (!back)
9569                         goto out;
9570                 if (back->node.found_ref) {
9571                         if (rec->refs)
9572                                 rec->refs--;
9573                         back->node.found_ref = 0;
9574                 }
9575                 if (back->node.found_extent_tree) {
9576                         if (rec->extent_item_refs)
9577                                 rec->extent_item_refs--;
9578                         back->node.found_extent_tree = 0;
9579                 }
9580                 if (!back->node.found_extent_tree && back->node.found_ref) {
9581                         rb_erase(&back->node.node, &rec->backref_tree);
9582                         free(back);
9583                 }
9584         }
9585         maybe_free_extent_rec(extent_cache, rec);
9586 out:
9587         return 0;
9588 }
9589
9590 static int delete_extent_records(struct btrfs_trans_handle *trans,
9591                                  struct btrfs_root *root,
9592                                  struct btrfs_path *path,
9593                                  u64 bytenr)
9594 {
9595         struct btrfs_key key;
9596         struct btrfs_key found_key;
9597         struct extent_buffer *leaf;
9598         int ret;
9599         int slot;
9600
9601
9602         key.objectid = bytenr;
9603         key.type = (u8)-1;
9604         key.offset = (u64)-1;
9605
9606         while(1) {
9607                 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
9608                                         &key, path, 0, 1);
9609                 if (ret < 0)
9610                         break;
9611
9612                 if (ret > 0) {
9613                         ret = 0;
9614                         if (path->slots[0] == 0)
9615                                 break;
9616                         path->slots[0]--;
9617                 }
9618                 ret = 0;
9619
9620                 leaf = path->nodes[0];
9621                 slot = path->slots[0];
9622
9623                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
9624                 if (found_key.objectid != bytenr)
9625                         break;
9626
9627                 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
9628                     found_key.type != BTRFS_METADATA_ITEM_KEY &&
9629                     found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
9630                     found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
9631                     found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
9632                     found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
9633                     found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
9634                         btrfs_release_path(path);
9635                         if (found_key.type == 0) {
9636                                 if (found_key.offset == 0)
9637                                         break;
9638                                 key.offset = found_key.offset - 1;
9639                                 key.type = found_key.type;
9640                         }
9641                         key.type = found_key.type - 1;
9642                         key.offset = (u64)-1;
9643                         continue;
9644                 }
9645
9646                 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
9647                         found_key.objectid, found_key.type, found_key.offset);
9648
9649                 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
9650                 if (ret)
9651                         break;
9652                 btrfs_release_path(path);
9653
9654                 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
9655                     found_key.type == BTRFS_METADATA_ITEM_KEY) {
9656                         u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
9657                                 found_key.offset : root->fs_info->nodesize;
9658
9659                         ret = btrfs_update_block_group(trans, root, bytenr,
9660                                                        bytes, 0, 0);
9661                         if (ret)
9662                                 break;
9663                 }
9664         }
9665
9666         btrfs_release_path(path);
9667         return ret;
9668 }
9669
9670 /*
9671  * for a single backref, this will allocate a new extent
9672  * and add the backref to it.
9673  */
9674 static int record_extent(struct btrfs_trans_handle *trans,
9675                          struct btrfs_fs_info *info,
9676                          struct btrfs_path *path,
9677                          struct extent_record *rec,
9678                          struct extent_backref *back,
9679                          int allocated, u64 flags)
9680 {
9681         int ret = 0;
9682         struct btrfs_root *extent_root = info->extent_root;
9683         struct extent_buffer *leaf;
9684         struct btrfs_key ins_key;
9685         struct btrfs_extent_item *ei;
9686         struct data_backref *dback;
9687         struct btrfs_tree_block_info *bi;
9688
9689         if (!back->is_data)
9690                 rec->max_size = max_t(u64, rec->max_size,
9691                                     info->nodesize);
9692
9693         if (!allocated) {
9694                 u32 item_size = sizeof(*ei);
9695
9696                 if (!back->is_data)
9697                         item_size += sizeof(*bi);
9698
9699                 ins_key.objectid = rec->start;
9700                 ins_key.offset = rec->max_size;
9701                 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
9702
9703                 ret = btrfs_insert_empty_item(trans, extent_root, path,
9704                                         &ins_key, item_size);
9705                 if (ret)
9706                         goto fail;
9707
9708                 leaf = path->nodes[0];
9709                 ei = btrfs_item_ptr(leaf, path->slots[0],
9710                                     struct btrfs_extent_item);
9711
9712                 btrfs_set_extent_refs(leaf, ei, 0);
9713                 btrfs_set_extent_generation(leaf, ei, rec->generation);
9714
9715                 if (back->is_data) {
9716                         btrfs_set_extent_flags(leaf, ei,
9717                                                BTRFS_EXTENT_FLAG_DATA);
9718                 } else {
9719                         struct btrfs_disk_key copy_key;;
9720
9721                         bi = (struct btrfs_tree_block_info *)(ei + 1);
9722                         memset_extent_buffer(leaf, 0, (unsigned long)bi,
9723                                              sizeof(*bi));
9724
9725                         btrfs_set_disk_key_objectid(&copy_key,
9726                                                     rec->info_objectid);
9727                         btrfs_set_disk_key_type(&copy_key, 0);
9728                         btrfs_set_disk_key_offset(&copy_key, 0);
9729
9730                         btrfs_set_tree_block_level(leaf, bi, rec->info_level);
9731                         btrfs_set_tree_block_key(leaf, bi, &copy_key);
9732
9733                         btrfs_set_extent_flags(leaf, ei,
9734                                                BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
9735                 }
9736
9737                 btrfs_mark_buffer_dirty(leaf);
9738                 ret = btrfs_update_block_group(trans, extent_root, rec->start,
9739                                                rec->max_size, 1, 0);
9740                 if (ret)
9741                         goto fail;
9742                 btrfs_release_path(path);
9743         }
9744
9745         if (back->is_data) {
9746                 u64 parent;
9747                 int i;
9748
9749                 dback = to_data_backref(back);
9750                 if (back->full_backref)
9751                         parent = dback->parent;
9752                 else
9753                         parent = 0;
9754
9755                 for (i = 0; i < dback->found_ref; i++) {
9756                         /* if parent != 0, we're doing a full backref
9757                          * passing BTRFS_FIRST_FREE_OBJECTID as the owner
9758                          * just makes the backref allocator create a data
9759                          * backref
9760                          */
9761                         ret = btrfs_inc_extent_ref(trans, info->extent_root,
9762                                                    rec->start, rec->max_size,
9763                                                    parent,
9764                                                    dback->root,
9765                                                    parent ?
9766                                                    BTRFS_FIRST_FREE_OBJECTID :
9767                                                    dback->owner,
9768                                                    dback->offset);
9769                         if (ret)
9770                                 break;
9771                 }
9772                 fprintf(stderr, "adding new data backref"
9773                                 " on %llu %s %llu owner %llu"
9774                                 " offset %llu found %d\n",
9775                                 (unsigned long long)rec->start,
9776                                 back->full_backref ?
9777                                 "parent" : "root",
9778                                 back->full_backref ?
9779                                 (unsigned long long)parent :
9780                                 (unsigned long long)dback->root,
9781                                 (unsigned long long)dback->owner,
9782                                 (unsigned long long)dback->offset,
9783                                 dback->found_ref);
9784         } else {
9785                 u64 parent;
9786                 struct tree_backref *tback;
9787
9788                 tback = to_tree_backref(back);
9789                 if (back->full_backref)
9790                         parent = tback->parent;
9791                 else
9792                         parent = 0;
9793
9794                 ret = btrfs_inc_extent_ref(trans, info->extent_root,
9795                                            rec->start, rec->max_size,
9796                                            parent, tback->root, 0, 0);
9797                 fprintf(stderr, "adding new tree backref on "
9798                         "start %llu len %llu parent %llu root %llu\n",
9799                         rec->start, rec->max_size, parent, tback->root);
9800         }
9801 fail:
9802         btrfs_release_path(path);
9803         return ret;
9804 }
9805
9806 static struct extent_entry *find_entry(struct list_head *entries,
9807                                        u64 bytenr, u64 bytes)
9808 {
9809         struct extent_entry *entry = NULL;
9810
9811         list_for_each_entry(entry, entries, list) {
9812                 if (entry->bytenr == bytenr && entry->bytes == bytes)
9813                         return entry;
9814         }
9815
9816         return NULL;
9817 }
9818
9819 static struct extent_entry *find_most_right_entry(struct list_head *entries)
9820 {
9821         struct extent_entry *entry, *best = NULL, *prev = NULL;
9822
9823         list_for_each_entry(entry, entries, list) {
9824                 /*
9825                  * If there are as many broken entries as entries then we know
9826                  * not to trust this particular entry.
9827                  */
9828                 if (entry->broken == entry->count)
9829                         continue;
9830
9831                 /*
9832                  * Special case, when there are only two entries and 'best' is
9833                  * the first one
9834                  */
9835                 if (!prev) {
9836                         best = entry;
9837                         prev = entry;
9838                         continue;
9839                 }
9840
9841                 /*
9842                  * If our current entry == best then we can't be sure our best
9843                  * is really the best, so we need to keep searching.
9844                  */
9845                 if (best && best->count == entry->count) {
9846                         prev = entry;
9847                         best = NULL;
9848                         continue;
9849                 }
9850
9851                 /* Prev == entry, not good enough, have to keep searching */
9852                 if (!prev->broken && prev->count == entry->count)
9853                         continue;
9854
9855                 if (!best)
9856                         best = (prev->count > entry->count) ? prev : entry;
9857                 else if (best->count < entry->count)
9858                         best = entry;
9859                 prev = entry;
9860         }
9861
9862         return best;
9863 }
9864
9865 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
9866                       struct data_backref *dback, struct extent_entry *entry)
9867 {
9868         struct btrfs_trans_handle *trans;
9869         struct btrfs_root *root;
9870         struct btrfs_file_extent_item *fi;
9871         struct extent_buffer *leaf;
9872         struct btrfs_key key;
9873         u64 bytenr, bytes;
9874         int ret, err;
9875
9876         key.objectid = dback->root;
9877         key.type = BTRFS_ROOT_ITEM_KEY;
9878         key.offset = (u64)-1;
9879         root = btrfs_read_fs_root(info, &key);
9880         if (IS_ERR(root)) {
9881                 fprintf(stderr, "Couldn't find root for our ref\n");
9882                 return -EINVAL;
9883         }
9884
9885         /*
9886          * The backref points to the original offset of the extent if it was
9887          * split, so we need to search down to the offset we have and then walk
9888          * forward until we find the backref we're looking for.
9889          */
9890         key.objectid = dback->owner;
9891         key.type = BTRFS_EXTENT_DATA_KEY;
9892         key.offset = dback->offset;
9893         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
9894         if (ret < 0) {
9895                 fprintf(stderr, "Error looking up ref %d\n", ret);
9896                 return ret;
9897         }
9898
9899         while (1) {
9900                 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
9901                         ret = btrfs_next_leaf(root, path);
9902                         if (ret) {
9903                                 fprintf(stderr, "Couldn't find our ref, next\n");
9904                                 return -EINVAL;
9905                         }
9906                 }
9907                 leaf = path->nodes[0];
9908                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
9909                 if (key.objectid != dback->owner ||
9910                     key.type != BTRFS_EXTENT_DATA_KEY) {
9911                         fprintf(stderr, "Couldn't find our ref, search\n");
9912                         return -EINVAL;
9913                 }
9914                 fi = btrfs_item_ptr(leaf, path->slots[0],
9915                                     struct btrfs_file_extent_item);
9916                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
9917                 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
9918
9919                 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
9920                         break;
9921                 path->slots[0]++;
9922         }
9923
9924         btrfs_release_path(path);
9925
9926         trans = btrfs_start_transaction(root, 1);
9927         if (IS_ERR(trans))
9928                 return PTR_ERR(trans);
9929
9930         /*
9931          * Ok we have the key of the file extent we want to fix, now we can cow
9932          * down to the thing and fix it.
9933          */
9934         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
9935         if (ret < 0) {
9936                 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
9937                         key.objectid, key.type, key.offset, ret);
9938                 goto out;
9939         }
9940         if (ret > 0) {
9941                 fprintf(stderr, "Well that's odd, we just found this key "
9942                         "[%Lu, %u, %Lu]\n", key.objectid, key.type,
9943                         key.offset);
9944                 ret = -EINVAL;
9945                 goto out;
9946         }
9947         leaf = path->nodes[0];
9948         fi = btrfs_item_ptr(leaf, path->slots[0],
9949                             struct btrfs_file_extent_item);
9950
9951         if (btrfs_file_extent_compression(leaf, fi) &&
9952             dback->disk_bytenr != entry->bytenr) {
9953                 fprintf(stderr, "Ref doesn't match the record start and is "
9954                         "compressed, please take a btrfs-image of this file "
9955                         "system and send it to a btrfs developer so they can "
9956                         "complete this functionality for bytenr %Lu\n",
9957                         dback->disk_bytenr);
9958                 ret = -EINVAL;
9959                 goto out;
9960         }
9961
9962         if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
9963                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
9964         } else if (dback->disk_bytenr > entry->bytenr) {
9965                 u64 off_diff, offset;
9966
9967                 off_diff = dback->disk_bytenr - entry->bytenr;
9968                 offset = btrfs_file_extent_offset(leaf, fi);
9969                 if (dback->disk_bytenr + offset +
9970                     btrfs_file_extent_num_bytes(leaf, fi) >
9971                     entry->bytenr + entry->bytes) {
9972                         fprintf(stderr, "Ref is past the entry end, please "
9973                                 "take a btrfs-image of this file system and "
9974                                 "send it to a btrfs developer, ref %Lu\n",
9975                                 dback->disk_bytenr);
9976                         ret = -EINVAL;
9977                         goto out;
9978                 }
9979                 offset += off_diff;
9980                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
9981                 btrfs_set_file_extent_offset(leaf, fi, offset);
9982         } else if (dback->disk_bytenr < entry->bytenr) {
9983                 u64 offset;
9984
9985                 offset = btrfs_file_extent_offset(leaf, fi);
9986                 if (dback->disk_bytenr + offset < entry->bytenr) {
9987                         fprintf(stderr, "Ref is before the entry start, please"
9988                                 " take a btrfs-image of this file system and "
9989                                 "send it to a btrfs developer, ref %Lu\n",
9990                                 dback->disk_bytenr);
9991                         ret = -EINVAL;
9992                         goto out;
9993                 }
9994
9995                 offset += dback->disk_bytenr;
9996                 offset -= entry->bytenr;
9997                 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
9998                 btrfs_set_file_extent_offset(leaf, fi, offset);
9999         }
10000
10001         btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
10002
10003         /*
10004          * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
10005          * only do this if we aren't using compression, otherwise it's a
10006          * trickier case.
10007          */
10008         if (!btrfs_file_extent_compression(leaf, fi))
10009                 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
10010         else
10011                 printf("ram bytes may be wrong?\n");
10012         btrfs_mark_buffer_dirty(leaf);
10013 out:
10014         err = btrfs_commit_transaction(trans, root);
10015         btrfs_release_path(path);
10016         return ret ? ret : err;
10017 }
10018
10019 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
10020                            struct extent_record *rec)
10021 {
10022         struct extent_backref *back, *tmp;
10023         struct data_backref *dback;
10024         struct extent_entry *entry, *best = NULL;
10025         LIST_HEAD(entries);
10026         int nr_entries = 0;
10027         int broken_entries = 0;
10028         int ret = 0;
10029         short mismatch = 0;
10030
10031         /*
10032          * Metadata is easy and the backrefs should always agree on bytenr and
10033          * size, if not we've got bigger issues.
10034          */
10035         if (rec->metadata)
10036                 return 0;
10037
10038         rbtree_postorder_for_each_entry_safe(back, tmp,
10039                                              &rec->backref_tree, node) {
10040                 if (back->full_backref || !back->is_data)
10041                         continue;
10042
10043                 dback = to_data_backref(back);
10044
10045                 /*
10046                  * We only pay attention to backrefs that we found a real
10047                  * backref for.
10048                  */
10049                 if (dback->found_ref == 0)
10050                         continue;
10051
10052                 /*
10053                  * For now we only catch when the bytes don't match, not the
10054                  * bytenr.  We can easily do this at the same time, but I want
10055                  * to have a fs image to test on before we just add repair
10056                  * functionality willy-nilly so we know we won't screw up the
10057                  * repair.
10058                  */
10059
10060                 entry = find_entry(&entries, dback->disk_bytenr,
10061                                    dback->bytes);
10062                 if (!entry) {
10063                         entry = malloc(sizeof(struct extent_entry));
10064                         if (!entry) {
10065                                 ret = -ENOMEM;
10066                                 goto out;
10067                         }
10068                         memset(entry, 0, sizeof(*entry));
10069                         entry->bytenr = dback->disk_bytenr;
10070                         entry->bytes = dback->bytes;
10071                         list_add_tail(&entry->list, &entries);
10072                         nr_entries++;
10073                 }
10074
10075                 /*
10076                  * If we only have on entry we may think the entries agree when
10077                  * in reality they don't so we have to do some extra checking.
10078                  */
10079                 if (dback->disk_bytenr != rec->start ||
10080                     dback->bytes != rec->nr || back->broken)
10081                         mismatch = 1;
10082
10083                 if (back->broken) {
10084                         entry->broken++;
10085                         broken_entries++;
10086                 }
10087
10088                 entry->count++;
10089         }
10090
10091         /* Yay all the backrefs agree, carry on good sir */
10092         if (nr_entries <= 1 && !mismatch)
10093                 goto out;
10094
10095         fprintf(stderr, "attempting to repair backref discrepency for bytenr "
10096                 "%Lu\n", rec->start);
10097
10098         /*
10099          * First we want to see if the backrefs can agree amongst themselves who
10100          * is right, so figure out which one of the entries has the highest
10101          * count.
10102          */
10103         best = find_most_right_entry(&entries);
10104
10105         /*
10106          * Ok so we may have an even split between what the backrefs think, so
10107          * this is where we use the extent ref to see what it thinks.
10108          */
10109         if (!best) {
10110                 entry = find_entry(&entries, rec->start, rec->nr);
10111                 if (!entry && (!broken_entries || !rec->found_rec)) {
10112                         fprintf(stderr, "Backrefs don't agree with each other "
10113                                 "and extent record doesn't agree with anybody,"
10114                                 " so we can't fix bytenr %Lu bytes %Lu\n",
10115                                 rec->start, rec->nr);
10116                         ret = -EINVAL;
10117                         goto out;
10118                 } else if (!entry) {
10119                         /*
10120                          * Ok our backrefs were broken, we'll assume this is the
10121                          * correct value and add an entry for this range.
10122                          */
10123                         entry = malloc(sizeof(struct extent_entry));
10124                         if (!entry) {
10125                                 ret = -ENOMEM;
10126                                 goto out;
10127                         }
10128                         memset(entry, 0, sizeof(*entry));
10129                         entry->bytenr = rec->start;
10130                         entry->bytes = rec->nr;
10131                         list_add_tail(&entry->list, &entries);
10132                         nr_entries++;
10133                 }
10134                 entry->count++;
10135                 best = find_most_right_entry(&entries);
10136                 if (!best) {
10137                         fprintf(stderr, "Backrefs and extent record evenly "
10138                                 "split on who is right, this is going to "
10139                                 "require user input to fix bytenr %Lu bytes "
10140                                 "%Lu\n", rec->start, rec->nr);
10141                         ret = -EINVAL;
10142                         goto out;
10143                 }
10144         }
10145
10146         /*
10147          * I don't think this can happen currently as we'll abort() if we catch
10148          * this case higher up, but in case somebody removes that we still can't
10149          * deal with it properly here yet, so just bail out of that's the case.
10150          */
10151         if (best->bytenr != rec->start) {
10152                 fprintf(stderr, "Extent start and backref starts don't match, "
10153                         "please use btrfs-image on this file system and send "
10154                         "it to a btrfs developer so they can make fsck fix "
10155                         "this particular case.  bytenr is %Lu, bytes is %Lu\n",
10156                         rec->start, rec->nr);
10157                 ret = -EINVAL;
10158                 goto out;
10159         }
10160
10161         /*
10162          * Ok great we all agreed on an extent record, let's go find the real
10163          * references and fix up the ones that don't match.
10164          */
10165         rbtree_postorder_for_each_entry_safe(back, tmp,
10166                                              &rec->backref_tree, node) {
10167                 if (back->full_backref || !back->is_data)
10168                         continue;
10169
10170                 dback = to_data_backref(back);
10171
10172                 /*
10173                  * Still ignoring backrefs that don't have a real ref attached
10174                  * to them.
10175                  */
10176                 if (dback->found_ref == 0)
10177                         continue;
10178
10179                 if (dback->bytes == best->bytes &&
10180                     dback->disk_bytenr == best->bytenr)
10181                         continue;
10182
10183                 ret = repair_ref(info, path, dback, best);
10184                 if (ret)
10185                         goto out;
10186         }
10187
10188         /*
10189          * Ok we messed with the actual refs, which means we need to drop our
10190          * entire cache and go back and rescan.  I know this is a huge pain and
10191          * adds a lot of extra work, but it's the only way to be safe.  Once all
10192          * the backrefs agree we may not need to do anything to the extent
10193          * record itself.
10194          */
10195         ret = -EAGAIN;
10196 out:
10197         while (!list_empty(&entries)) {
10198                 entry = list_entry(entries.next, struct extent_entry, list);
10199                 list_del_init(&entry->list);
10200                 free(entry);
10201         }
10202         return ret;
10203 }
10204
10205 static int process_duplicates(struct cache_tree *extent_cache,
10206                               struct extent_record *rec)
10207 {
10208         struct extent_record *good, *tmp;
10209         struct cache_extent *cache;
10210         int ret;
10211
10212         /*
10213          * If we found a extent record for this extent then return, or if we
10214          * have more than one duplicate we are likely going to need to delete
10215          * something.
10216          */
10217         if (rec->found_rec || rec->num_duplicates > 1)
10218                 return 0;
10219
10220         /* Shouldn't happen but just in case */
10221         BUG_ON(!rec->num_duplicates);
10222
10223         /*
10224          * So this happens if we end up with a backref that doesn't match the
10225          * actual extent entry.  So either the backref is bad or the extent
10226          * entry is bad.  Either way we want to have the extent_record actually
10227          * reflect what we found in the extent_tree, so we need to take the
10228          * duplicate out and use that as the extent_record since the only way we
10229          * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
10230          */
10231         remove_cache_extent(extent_cache, &rec->cache);
10232
10233         good = to_extent_record(rec->dups.next);
10234         list_del_init(&good->list);
10235         INIT_LIST_HEAD(&good->backrefs);
10236         INIT_LIST_HEAD(&good->dups);
10237         good->cache.start = good->start;
10238         good->cache.size = good->nr;
10239         good->content_checked = 0;
10240         good->owner_ref_checked = 0;
10241         good->num_duplicates = 0;
10242         good->refs = rec->refs;
10243         list_splice_init(&rec->backrefs, &good->backrefs);
10244         while (1) {
10245                 cache = lookup_cache_extent(extent_cache, good->start,
10246                                             good->nr);
10247                 if (!cache)
10248                         break;
10249                 tmp = container_of(cache, struct extent_record, cache);
10250
10251                 /*
10252                  * If we find another overlapping extent and it's found_rec is
10253                  * set then it's a duplicate and we need to try and delete
10254                  * something.
10255                  */
10256                 if (tmp->found_rec || tmp->num_duplicates > 0) {
10257                         if (list_empty(&good->list))
10258                                 list_add_tail(&good->list,
10259                                               &duplicate_extents);
10260                         good->num_duplicates += tmp->num_duplicates + 1;
10261                         list_splice_init(&tmp->dups, &good->dups);
10262                         list_del_init(&tmp->list);
10263                         list_add_tail(&tmp->list, &good->dups);
10264                         remove_cache_extent(extent_cache, &tmp->cache);
10265                         continue;
10266                 }
10267
10268                 /*
10269                  * Ok we have another non extent item backed extent rec, so lets
10270                  * just add it to this extent and carry on like we did above.
10271                  */
10272                 good->refs += tmp->refs;
10273                 list_splice_init(&tmp->backrefs, &good->backrefs);
10274                 remove_cache_extent(extent_cache, &tmp->cache);
10275                 free(tmp);
10276         }
10277         ret = insert_cache_extent(extent_cache, &good->cache);
10278         BUG_ON(ret);
10279         free(rec);
10280         return good->num_duplicates ? 0 : 1;
10281 }
10282
10283 static int delete_duplicate_records(struct btrfs_root *root,
10284                                     struct extent_record *rec)
10285 {
10286         struct btrfs_trans_handle *trans;
10287         LIST_HEAD(delete_list);
10288         struct btrfs_path path;
10289         struct extent_record *tmp, *good, *n;
10290         int nr_del = 0;
10291         int ret = 0, err;
10292         struct btrfs_key key;
10293
10294         btrfs_init_path(&path);
10295
10296         good = rec;
10297         /* Find the record that covers all of the duplicates. */
10298         list_for_each_entry(tmp, &rec->dups, list) {
10299                 if (good->start < tmp->start)
10300                         continue;
10301                 if (good->nr > tmp->nr)
10302                         continue;
10303
10304                 if (tmp->start + tmp->nr < good->start + good->nr) {
10305                         fprintf(stderr, "Ok we have overlapping extents that "
10306                                 "aren't completely covered by each other, this "
10307                                 "is going to require more careful thought.  "
10308                                 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
10309                                 tmp->start, tmp->nr, good->start, good->nr);
10310                         abort();
10311                 }
10312                 good = tmp;
10313         }
10314
10315         if (good != rec)
10316                 list_add_tail(&rec->list, &delete_list);
10317
10318         list_for_each_entry_safe(tmp, n, &rec->dups, list) {
10319                 if (tmp == good)
10320                         continue;
10321                 list_move_tail(&tmp->list, &delete_list);
10322         }
10323
10324         root = root->fs_info->extent_root;
10325         trans = btrfs_start_transaction(root, 1);
10326         if (IS_ERR(trans)) {
10327                 ret = PTR_ERR(trans);
10328                 goto out;
10329         }
10330
10331         list_for_each_entry(tmp, &delete_list, list) {
10332                 if (tmp->found_rec == 0)
10333                         continue;
10334                 key.objectid = tmp->start;
10335                 key.type = BTRFS_EXTENT_ITEM_KEY;
10336                 key.offset = tmp->nr;
10337
10338                 /* Shouldn't happen but just in case */
10339                 if (tmp->metadata) {
10340                         fprintf(stderr, "Well this shouldn't happen, extent "
10341                                 "record overlaps but is metadata? "
10342                                 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
10343                         abort();
10344                 }
10345
10346                 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
10347                 if (ret) {
10348                         if (ret > 0)
10349                                 ret = -EINVAL;
10350                         break;
10351                 }
10352                 ret = btrfs_del_item(trans, root, &path);
10353                 if (ret)
10354                         break;
10355                 btrfs_release_path(&path);
10356                 nr_del++;
10357         }
10358         err = btrfs_commit_transaction(trans, root);
10359         if (err && !ret)
10360                 ret = err;
10361 out:
10362         while (!list_empty(&delete_list)) {
10363                 tmp = to_extent_record(delete_list.next);
10364                 list_del_init(&tmp->list);
10365                 if (tmp == rec)
10366                         continue;
10367                 free(tmp);
10368         }
10369
10370         while (!list_empty(&rec->dups)) {
10371                 tmp = to_extent_record(rec->dups.next);
10372                 list_del_init(&tmp->list);
10373                 free(tmp);
10374         }
10375
10376         btrfs_release_path(&path);
10377
10378         if (!ret && !nr_del)
10379                 rec->num_duplicates = 0;
10380
10381         return ret ? ret : nr_del;
10382 }
10383
10384 static int find_possible_backrefs(struct btrfs_fs_info *info,
10385                                   struct btrfs_path *path,
10386                                   struct cache_tree *extent_cache,
10387                                   struct extent_record *rec)
10388 {
10389         struct btrfs_root *root;
10390         struct extent_backref *back, *tmp;
10391         struct data_backref *dback;
10392         struct cache_extent *cache;
10393         struct btrfs_file_extent_item *fi;
10394         struct btrfs_key key;
10395         u64 bytenr, bytes;
10396         int ret;
10397
10398         rbtree_postorder_for_each_entry_safe(back, tmp,
10399                                              &rec->backref_tree, node) {
10400                 /* Don't care about full backrefs (poor unloved backrefs) */
10401                 if (back->full_backref || !back->is_data)
10402                         continue;
10403
10404                 dback = to_data_backref(back);
10405
10406                 /* We found this one, we don't need to do a lookup */
10407                 if (dback->found_ref)
10408                         continue;
10409
10410                 key.objectid = dback->root;
10411                 key.type = BTRFS_ROOT_ITEM_KEY;
10412                 key.offset = (u64)-1;
10413
10414                 root = btrfs_read_fs_root(info, &key);
10415
10416                 /* No root, definitely a bad ref, skip */
10417                 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
10418                         continue;
10419                 /* Other err, exit */
10420                 if (IS_ERR(root))
10421                         return PTR_ERR(root);
10422
10423                 key.objectid = dback->owner;
10424                 key.type = BTRFS_EXTENT_DATA_KEY;
10425                 key.offset = dback->offset;
10426                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
10427                 if (ret) {
10428                         btrfs_release_path(path);
10429                         if (ret < 0)
10430                                 return ret;
10431                         /* Didn't find it, we can carry on */
10432                         ret = 0;
10433                         continue;
10434                 }
10435
10436                 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
10437                                     struct btrfs_file_extent_item);
10438                 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
10439                 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
10440                 btrfs_release_path(path);
10441                 cache = lookup_cache_extent(extent_cache, bytenr, 1);
10442                 if (cache) {
10443                         struct extent_record *tmp;
10444                         tmp = container_of(cache, struct extent_record, cache);
10445
10446                         /*
10447                          * If we found an extent record for the bytenr for this
10448                          * particular backref then we can't add it to our
10449                          * current extent record.  We only want to add backrefs
10450                          * that don't have a corresponding extent item in the
10451                          * extent tree since they likely belong to this record
10452                          * and we need to fix it if it doesn't match bytenrs.
10453                          */
10454                         if  (tmp->found_rec)
10455                                 continue;
10456                 }
10457
10458                 dback->found_ref += 1;
10459                 dback->disk_bytenr = bytenr;
10460                 dback->bytes = bytes;
10461
10462                 /*
10463                  * Set this so the verify backref code knows not to trust the
10464                  * values in this backref.
10465                  */
10466                 back->broken = 1;
10467         }
10468
10469         return 0;
10470 }
10471
10472 /*
10473  * Record orphan data ref into corresponding root.
10474  *
10475  * Return 0 if the extent item contains data ref and recorded.
10476  * Return 1 if the extent item contains no useful data ref
10477  *   On that case, it may contains only shared_dataref or metadata backref
10478  *   or the file extent exists(this should be handled by the extent bytenr
10479  *   recovery routine)
10480  * Return <0 if something goes wrong.
10481  */
10482 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
10483                                       struct extent_record *rec)
10484 {
10485         struct btrfs_key key;
10486         struct btrfs_root *dest_root;
10487         struct extent_backref *back, *tmp;
10488         struct data_backref *dback;
10489         struct orphan_data_extent *orphan;
10490         struct btrfs_path path;
10491         int recorded_data_ref = 0;
10492         int ret = 0;
10493
10494         if (rec->metadata)
10495                 return 1;
10496         btrfs_init_path(&path);
10497         rbtree_postorder_for_each_entry_safe(back, tmp,
10498                                              &rec->backref_tree, node) {
10499                 if (back->full_backref || !back->is_data ||
10500                     !back->found_extent_tree)
10501                         continue;
10502                 dback = to_data_backref(back);
10503                 if (dback->found_ref)
10504                         continue;
10505                 key.objectid = dback->root;
10506                 key.type = BTRFS_ROOT_ITEM_KEY;
10507                 key.offset = (u64)-1;
10508
10509                 dest_root = btrfs_read_fs_root(fs_info, &key);
10510
10511                 /* For non-exist root we just skip it */
10512                 if (IS_ERR(dest_root) || !dest_root)
10513                         continue;
10514
10515                 key.objectid = dback->owner;
10516                 key.type = BTRFS_EXTENT_DATA_KEY;
10517                 key.offset = dback->offset;
10518
10519                 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
10520                 btrfs_release_path(&path);
10521                 /*
10522                  * For ret < 0, it's OK since the fs-tree may be corrupted,
10523                  * we need to record it for inode/file extent rebuild.
10524                  * For ret > 0, we record it only for file extent rebuild.
10525                  * For ret == 0, the file extent exists but only bytenr
10526                  * mismatch, let the original bytenr fix routine to handle,
10527                  * don't record it.
10528                  */
10529                 if (ret == 0)
10530                         continue;
10531                 ret = 0;
10532                 orphan = malloc(sizeof(*orphan));
10533                 if (!orphan) {
10534                         ret = -ENOMEM;
10535                         goto out;
10536                 }
10537                 INIT_LIST_HEAD(&orphan->list);
10538                 orphan->root = dback->root;
10539                 orphan->objectid = dback->owner;
10540                 orphan->offset = dback->offset;
10541                 orphan->disk_bytenr = rec->cache.start;
10542                 orphan->disk_len = rec->cache.size;
10543                 list_add(&dest_root->orphan_data_extents, &orphan->list);
10544                 recorded_data_ref = 1;
10545         }
10546 out:
10547         btrfs_release_path(&path);
10548         if (!ret)
10549                 return !recorded_data_ref;
10550         else
10551                 return ret;
10552 }
10553
10554 /*
10555  * when an incorrect extent item is found, this will delete
10556  * all of the existing entries for it and recreate them
10557  * based on what the tree scan found.
10558  */
10559 static int fixup_extent_refs(struct btrfs_fs_info *info,
10560                              struct cache_tree *extent_cache,
10561                              struct extent_record *rec)
10562 {
10563         struct btrfs_trans_handle *trans = NULL;
10564         int ret;
10565         struct btrfs_path path;
10566         struct cache_extent *cache;
10567         struct extent_backref *back, *tmp;
10568         int allocated = 0;
10569         u64 flags = 0;
10570
10571         if (rec->flag_block_full_backref)
10572                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
10573
10574         btrfs_init_path(&path);
10575         if (rec->refs != rec->extent_item_refs && !rec->metadata) {
10576                 /*
10577                  * Sometimes the backrefs themselves are so broken they don't
10578                  * get attached to any meaningful rec, so first go back and
10579                  * check any of our backrefs that we couldn't find and throw
10580                  * them into the list if we find the backref so that
10581                  * verify_backrefs can figure out what to do.
10582                  */
10583                 ret = find_possible_backrefs(info, &path, extent_cache, rec);
10584                 if (ret < 0)
10585                         goto out;
10586         }
10587
10588         /* step one, make sure all of the backrefs agree */
10589         ret = verify_backrefs(info, &path, rec);
10590         if (ret < 0)
10591                 goto out;
10592
10593         trans = btrfs_start_transaction(info->extent_root, 1);
10594         if (IS_ERR(trans)) {
10595                 ret = PTR_ERR(trans);
10596                 goto out;
10597         }
10598
10599         /* step two, delete all the existing records */
10600         ret = delete_extent_records(trans, info->extent_root, &path,
10601                                     rec->start);
10602
10603         if (ret < 0)
10604                 goto out;
10605
10606         /* was this block corrupt?  If so, don't add references to it */
10607         cache = lookup_cache_extent(info->corrupt_blocks,
10608                                     rec->start, rec->max_size);
10609         if (cache) {
10610                 ret = 0;
10611                 goto out;
10612         }
10613
10614         /* step three, recreate all the refs we did find */
10615         rbtree_postorder_for_each_entry_safe(back, tmp,
10616                                              &rec->backref_tree, node) {
10617                 /*
10618                  * if we didn't find any references, don't create a
10619                  * new extent record
10620                  */
10621                 if (!back->found_ref)
10622                         continue;
10623
10624                 rec->bad_full_backref = 0;
10625                 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
10626                 allocated = 1;
10627
10628                 if (ret)
10629                         goto out;
10630         }
10631 out:
10632         if (trans) {
10633                 int err = btrfs_commit_transaction(trans, info->extent_root);
10634                 if (!ret)
10635                         ret = err;
10636         }
10637
10638         if (!ret)
10639                 fprintf(stderr, "Repaired extent references for %llu\n",
10640                                 (unsigned long long)rec->start);
10641
10642         btrfs_release_path(&path);
10643         return ret;
10644 }
10645
10646 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
10647                               struct extent_record *rec)
10648 {
10649         struct btrfs_trans_handle *trans;
10650         struct btrfs_root *root = fs_info->extent_root;
10651         struct btrfs_path path;
10652         struct btrfs_extent_item *ei;
10653         struct btrfs_key key;
10654         u64 flags;
10655         int ret = 0;
10656
10657         key.objectid = rec->start;
10658         if (rec->metadata) {
10659                 key.type = BTRFS_METADATA_ITEM_KEY;
10660                 key.offset = rec->info_level;
10661         } else {
10662                 key.type = BTRFS_EXTENT_ITEM_KEY;
10663                 key.offset = rec->max_size;
10664         }
10665
10666         trans = btrfs_start_transaction(root, 0);
10667         if (IS_ERR(trans))
10668                 return PTR_ERR(trans);
10669
10670         btrfs_init_path(&path);
10671         ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
10672         if (ret < 0) {
10673                 btrfs_release_path(&path);
10674                 btrfs_commit_transaction(trans, root);
10675                 return ret;
10676         } else if (ret) {
10677                 fprintf(stderr, "Didn't find extent for %llu\n",
10678                         (unsigned long long)rec->start);
10679                 btrfs_release_path(&path);
10680                 btrfs_commit_transaction(trans, root);
10681                 return -ENOENT;
10682         }
10683
10684         ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10685                             struct btrfs_extent_item);
10686         flags = btrfs_extent_flags(path.nodes[0], ei);
10687         if (rec->flag_block_full_backref) {
10688                 fprintf(stderr, "setting full backref on %llu\n",
10689                         (unsigned long long)key.objectid);
10690                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
10691         } else {
10692                 fprintf(stderr, "clearing full backref on %llu\n",
10693                         (unsigned long long)key.objectid);
10694                 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
10695         }
10696         btrfs_set_extent_flags(path.nodes[0], ei, flags);
10697         btrfs_mark_buffer_dirty(path.nodes[0]);
10698         btrfs_release_path(&path);
10699         ret = btrfs_commit_transaction(trans, root);
10700         if (!ret)
10701                 fprintf(stderr, "Repaired extent flags for %llu\n",
10702                                 (unsigned long long)rec->start);
10703
10704         return ret;
10705 }
10706
10707 /* right now we only prune from the extent allocation tree */
10708 static int prune_one_block(struct btrfs_trans_handle *trans,
10709                            struct btrfs_fs_info *info,
10710                            struct btrfs_corrupt_block *corrupt)
10711 {
10712         int ret;
10713         struct btrfs_path path;
10714         struct extent_buffer *eb;
10715         u64 found;
10716         int slot;
10717         int nritems;
10718         int level = corrupt->level + 1;
10719
10720         btrfs_init_path(&path);
10721 again:
10722         /* we want to stop at the parent to our busted block */
10723         path.lowest_level = level;
10724
10725         ret = btrfs_search_slot(trans, info->extent_root,
10726                                 &corrupt->key, &path, -1, 1);
10727
10728         if (ret < 0)
10729                 goto out;
10730
10731         eb = path.nodes[level];
10732         if (!eb) {
10733                 ret = -ENOENT;
10734                 goto out;
10735         }
10736
10737         /*
10738          * hopefully the search gave us the block we want to prune,
10739          * lets try that first
10740          */
10741         slot = path.slots[level];
10742         found =  btrfs_node_blockptr(eb, slot);
10743         if (found == corrupt->cache.start)
10744                 goto del_ptr;
10745
10746         nritems = btrfs_header_nritems(eb);
10747
10748         /* the search failed, lets scan this node and hope we find it */
10749         for (slot = 0; slot < nritems; slot++) {
10750                 found =  btrfs_node_blockptr(eb, slot);
10751                 if (found == corrupt->cache.start)
10752                         goto del_ptr;
10753         }
10754         /*
10755          * we couldn't find the bad block.  TODO, search all the nodes for pointers
10756          * to this block
10757          */
10758         if (eb == info->extent_root->node) {
10759                 ret = -ENOENT;
10760                 goto out;
10761         } else {
10762                 level++;
10763                 btrfs_release_path(&path);
10764                 goto again;
10765         }
10766
10767 del_ptr:
10768         printk("deleting pointer to block %Lu\n", corrupt->cache.start);
10769         ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
10770
10771 out:
10772         btrfs_release_path(&path);
10773         return ret;
10774 }
10775
10776 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
10777 {
10778         struct btrfs_trans_handle *trans = NULL;
10779         struct cache_extent *cache;
10780         struct btrfs_corrupt_block *corrupt;
10781
10782         while (1) {
10783                 cache = search_cache_extent(info->corrupt_blocks, 0);
10784                 if (!cache)
10785                         break;
10786                 if (!trans) {
10787                         trans = btrfs_start_transaction(info->extent_root, 1);
10788                         if (IS_ERR(trans))
10789                                 return PTR_ERR(trans);
10790                 }
10791                 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
10792                 prune_one_block(trans, info, corrupt);
10793                 remove_cache_extent(info->corrupt_blocks, cache);
10794         }
10795         if (trans)
10796                 return btrfs_commit_transaction(trans, info->extent_root);
10797         return 0;
10798 }
10799
10800 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
10801 {
10802         struct btrfs_block_group_cache *cache;
10803         u64 start, end;
10804         int ret;
10805
10806         while (1) {
10807                 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
10808                                             &start, &end, EXTENT_DIRTY);
10809                 if (ret)
10810                         break;
10811                 clear_extent_dirty(&fs_info->free_space_cache, start, end);
10812         }
10813
10814         start = 0;
10815         while (1) {
10816                 cache = btrfs_lookup_first_block_group(fs_info, start);
10817                 if (!cache)
10818                         break;
10819                 if (cache->cached)
10820                         cache->cached = 0;
10821                 start = cache->key.objectid + cache->key.offset;
10822         }
10823 }
10824
10825 static int check_extent_refs(struct btrfs_root *root,
10826                              struct cache_tree *extent_cache)
10827 {
10828         struct extent_record *rec;
10829         struct cache_extent *cache;
10830         int ret = 0;
10831         int had_dups = 0;
10832         int err = 0;
10833
10834         if (repair) {
10835                 /*
10836                  * if we're doing a repair, we have to make sure
10837                  * we don't allocate from the problem extents.
10838                  * In the worst case, this will be all the
10839                  * extents in the FS
10840                  */
10841                 cache = search_cache_extent(extent_cache, 0);
10842                 while(cache) {
10843                         rec = container_of(cache, struct extent_record, cache);
10844                         set_extent_dirty(root->fs_info->excluded_extents,
10845                                          rec->start,
10846                                          rec->start + rec->max_size - 1);
10847                         cache = next_cache_extent(cache);
10848                 }
10849
10850                 /* pin down all the corrupted blocks too */
10851                 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
10852                 while(cache) {
10853                         set_extent_dirty(root->fs_info->excluded_extents,
10854                                          cache->start,
10855                                          cache->start + cache->size - 1);
10856                         cache = next_cache_extent(cache);
10857                 }
10858                 prune_corrupt_blocks(root->fs_info);
10859                 reset_cached_block_groups(root->fs_info);
10860         }
10861
10862         reset_cached_block_groups(root->fs_info);
10863
10864         /*
10865          * We need to delete any duplicate entries we find first otherwise we
10866          * could mess up the extent tree when we have backrefs that actually
10867          * belong to a different extent item and not the weird duplicate one.
10868          */
10869         while (repair && !list_empty(&duplicate_extents)) {
10870                 rec = to_extent_record(duplicate_extents.next);
10871                 list_del_init(&rec->list);
10872
10873                 /* Sometimes we can find a backref before we find an actual
10874                  * extent, so we need to process it a little bit to see if there
10875                  * truly are multiple EXTENT_ITEM_KEY's for the same range, or
10876                  * if this is a backref screwup.  If we need to delete stuff
10877                  * process_duplicates() will return 0, otherwise it will return
10878                  * 1 and we
10879                  */
10880                 if (process_duplicates(extent_cache, rec))
10881                         continue;
10882                 ret = delete_duplicate_records(root, rec);
10883                 if (ret < 0)
10884                         return ret;
10885                 /*
10886                  * delete_duplicate_records will return the number of entries
10887                  * deleted, so if it's greater than 0 then we know we actually
10888                  * did something and we need to remove.
10889                  */
10890                 if (ret)
10891                         had_dups = 1;
10892         }
10893
10894         if (had_dups)
10895                 return -EAGAIN;
10896
10897         while(1) {
10898                 int cur_err = 0;
10899                 int fix = 0;
10900
10901                 cache = search_cache_extent(extent_cache, 0);
10902                 if (!cache)
10903                         break;
10904                 rec = container_of(cache, struct extent_record, cache);
10905                 if (rec->num_duplicates) {
10906                         fprintf(stderr, "extent item %llu has multiple extent "
10907                                 "items\n", (unsigned long long)rec->start);
10908                         cur_err = 1;
10909                 }
10910
10911                 if (rec->refs != rec->extent_item_refs) {
10912                         fprintf(stderr, "ref mismatch on [%llu %llu] ",
10913                                 (unsigned long long)rec->start,
10914                                 (unsigned long long)rec->nr);
10915                         fprintf(stderr, "extent item %llu, found %llu\n",
10916                                 (unsigned long long)rec->extent_item_refs,
10917                                 (unsigned long long)rec->refs);
10918                         ret = record_orphan_data_extents(root->fs_info, rec);
10919                         if (ret < 0)
10920                                 goto repair_abort;
10921                         fix = ret;
10922                         cur_err = 1;
10923                 }
10924                 if (all_backpointers_checked(rec, 1)) {
10925                         fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
10926                                 (unsigned long long)rec->start,
10927                                 (unsigned long long)rec->nr);
10928                         fix = 1;
10929                         cur_err = 1;
10930                 }
10931                 if (!rec->owner_ref_checked) {
10932                         fprintf(stderr, "owner ref check failed [%llu %llu]\n",
10933                                 (unsigned long long)rec->start,
10934                                 (unsigned long long)rec->nr);
10935                         fix = 1;
10936                         cur_err = 1;
10937                 }
10938
10939                 if (repair && fix) {
10940                         ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
10941                         if (ret)
10942                                 goto repair_abort;
10943                 }
10944
10945
10946                 if (rec->bad_full_backref) {
10947                         fprintf(stderr, "bad full backref, on [%llu]\n",
10948                                 (unsigned long long)rec->start);
10949                         if (repair) {
10950                                 ret = fixup_extent_flags(root->fs_info, rec);
10951                                 if (ret)
10952                                         goto repair_abort;
10953                                 fix = 1;
10954                         }
10955                         cur_err = 1;
10956                 }
10957                 /*
10958                  * Although it's not a extent ref's problem, we reuse this
10959                  * routine for error reporting.
10960                  * No repair function yet.
10961                  */
10962                 if (rec->crossing_stripes) {
10963                         fprintf(stderr,
10964                                 "bad metadata [%llu, %llu) crossing stripe boundary\n",
10965                                 rec->start, rec->start + rec->max_size);
10966                         cur_err = 1;
10967                 }
10968
10969                 if (rec->wrong_chunk_type) {
10970                         fprintf(stderr,
10971                                 "bad extent [%llu, %llu), type mismatch with chunk\n",
10972                                 rec->start, rec->start + rec->max_size);
10973                         cur_err = 1;
10974                 }
10975
10976                 err = cur_err;
10977                 remove_cache_extent(extent_cache, cache);
10978                 free_all_extent_backrefs(rec);
10979                 if (!init_extent_tree && repair && (!cur_err || fix))
10980                         clear_extent_dirty(root->fs_info->excluded_extents,
10981                                            rec->start,
10982                                            rec->start + rec->max_size - 1);
10983                 free(rec);
10984         }
10985 repair_abort:
10986         if (repair) {
10987                 if (ret && ret != -EAGAIN) {
10988                         fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
10989                         exit(1);
10990                 } else if (!ret) {
10991                         struct btrfs_trans_handle *trans;
10992
10993                         root = root->fs_info->extent_root;
10994                         trans = btrfs_start_transaction(root, 1);
10995                         if (IS_ERR(trans)) {
10996                                 ret = PTR_ERR(trans);
10997                                 goto repair_abort;
10998                         }
10999
11000                         ret = btrfs_fix_block_accounting(trans, root);
11001                         if (ret)
11002                                 goto repair_abort;
11003                         ret = btrfs_commit_transaction(trans, root);
11004                         if (ret)
11005                                 goto repair_abort;
11006                 }
11007                 return ret;
11008         }
11009
11010         if (err)
11011                 err = -EIO;
11012         return err;
11013 }
11014
11015 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
11016 {
11017         u64 stripe_size;
11018
11019         if (type & BTRFS_BLOCK_GROUP_RAID0) {
11020                 stripe_size = length;
11021                 stripe_size /= num_stripes;
11022         } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
11023                 stripe_size = length * 2;
11024                 stripe_size /= num_stripes;
11025         } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
11026                 stripe_size = length;
11027                 stripe_size /= (num_stripes - 1);
11028         } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
11029                 stripe_size = length;
11030                 stripe_size /= (num_stripes - 2);
11031         } else {
11032                 stripe_size = length;
11033         }
11034         return stripe_size;
11035 }
11036
11037 /*
11038  * Check the chunk with its block group/dev list ref:
11039  * Return 0 if all refs seems valid.
11040  * Return 1 if part of refs seems valid, need later check for rebuild ref
11041  * like missing block group and needs to search extent tree to rebuild them.
11042  * Return -1 if essential refs are missing and unable to rebuild.
11043  */
11044 static int check_chunk_refs(struct chunk_record *chunk_rec,
11045                             struct block_group_tree *block_group_cache,
11046                             struct device_extent_tree *dev_extent_cache,
11047                             int silent)
11048 {
11049         struct cache_extent *block_group_item;
11050         struct block_group_record *block_group_rec;
11051         struct cache_extent *dev_extent_item;
11052         struct device_extent_record *dev_extent_rec;
11053         u64 devid;
11054         u64 offset;
11055         u64 length;
11056         int metadump_v2 = 0;
11057         int i;
11058         int ret = 0;
11059
11060         block_group_item = lookup_cache_extent(&block_group_cache->tree,
11061                                                chunk_rec->offset,
11062                                                chunk_rec->length);
11063         if (block_group_item) {
11064                 block_group_rec = container_of(block_group_item,
11065                                                struct block_group_record,
11066                                                cache);
11067                 if (chunk_rec->length != block_group_rec->offset ||
11068                     chunk_rec->offset != block_group_rec->objectid ||
11069                     (!metadump_v2 &&
11070                      chunk_rec->type_flags != block_group_rec->flags)) {
11071                         if (!silent)
11072                                 fprintf(stderr,
11073                                         "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
11074                                         chunk_rec->objectid,
11075                                         chunk_rec->type,
11076                                         chunk_rec->offset,
11077                                         chunk_rec->length,
11078                                         chunk_rec->offset,
11079                                         chunk_rec->type_flags,
11080                                         block_group_rec->objectid,
11081                                         block_group_rec->type,
11082                                         block_group_rec->offset,
11083                                         block_group_rec->offset,
11084                                         block_group_rec->objectid,
11085                                         block_group_rec->flags);
11086                         ret = -1;
11087                 } else {
11088                         list_del_init(&block_group_rec->list);
11089                         chunk_rec->bg_rec = block_group_rec;
11090                 }
11091         } else {
11092                 if (!silent)
11093                         fprintf(stderr,
11094                                 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
11095                                 chunk_rec->objectid,
11096                                 chunk_rec->type,
11097                                 chunk_rec->offset,
11098                                 chunk_rec->length,
11099                                 chunk_rec->offset,
11100                                 chunk_rec->type_flags);
11101                 ret = 1;
11102         }
11103
11104         if (metadump_v2)
11105                 return ret;
11106
11107         length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
11108                                     chunk_rec->num_stripes);
11109         for (i = 0; i < chunk_rec->num_stripes; ++i) {
11110                 devid = chunk_rec->stripes[i].devid;
11111                 offset = chunk_rec->stripes[i].offset;
11112                 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
11113                                                        devid, offset, length);
11114                 if (dev_extent_item) {
11115                         dev_extent_rec = container_of(dev_extent_item,
11116                                                 struct device_extent_record,
11117                                                 cache);
11118                         if (dev_extent_rec->objectid != devid ||
11119                             dev_extent_rec->offset != offset ||
11120                             dev_extent_rec->chunk_offset != chunk_rec->offset ||
11121                             dev_extent_rec->length != length) {
11122                                 if (!silent)
11123                                         fprintf(stderr,
11124                                                 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
11125                                                 chunk_rec->objectid,
11126                                                 chunk_rec->type,
11127                                                 chunk_rec->offset,
11128                                                 chunk_rec->stripes[i].devid,
11129                                                 chunk_rec->stripes[i].offset,
11130                                                 dev_extent_rec->objectid,
11131                                                 dev_extent_rec->offset,
11132                                                 dev_extent_rec->length);
11133                                 ret = -1;
11134                         } else {
11135                                 list_move(&dev_extent_rec->chunk_list,
11136                                           &chunk_rec->dextents);
11137                         }
11138                 } else {
11139                         if (!silent)
11140                                 fprintf(stderr,
11141                                         "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
11142                                         chunk_rec->objectid,
11143                                         chunk_rec->type,
11144                                         chunk_rec->offset,
11145                                         chunk_rec->stripes[i].devid,
11146                                         chunk_rec->stripes[i].offset);
11147                         ret = -1;
11148                 }
11149         }
11150         return ret;
11151 }
11152
11153 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
11154 int check_chunks(struct cache_tree *chunk_cache,
11155                  struct block_group_tree *block_group_cache,
11156                  struct device_extent_tree *dev_extent_cache,
11157                  struct list_head *good, struct list_head *bad,
11158                  struct list_head *rebuild, int silent)
11159 {
11160         struct cache_extent *chunk_item;
11161         struct chunk_record *chunk_rec;
11162         struct block_group_record *bg_rec;
11163         struct device_extent_record *dext_rec;
11164         int err;
11165         int ret = 0;
11166
11167         chunk_item = first_cache_extent(chunk_cache);
11168         while (chunk_item) {
11169                 chunk_rec = container_of(chunk_item, struct chunk_record,
11170                                          cache);
11171                 err = check_chunk_refs(chunk_rec, block_group_cache,
11172                                        dev_extent_cache, silent);
11173                 if (err < 0)
11174                         ret = err;
11175                 if (err == 0 && good)
11176                         list_add_tail(&chunk_rec->list, good);
11177                 if (err > 0 && rebuild)
11178                         list_add_tail(&chunk_rec->list, rebuild);
11179                 if (err < 0 && bad)
11180                         list_add_tail(&chunk_rec->list, bad);
11181                 chunk_item = next_cache_extent(chunk_item);
11182         }
11183
11184         list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
11185                 if (!silent)
11186                         fprintf(stderr,
11187                                 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
11188                                 bg_rec->objectid,
11189                                 bg_rec->offset,
11190                                 bg_rec->flags);
11191                 if (!ret)
11192                         ret = 1;
11193         }
11194
11195         list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
11196                             chunk_list) {
11197                 if (!silent)
11198                         fprintf(stderr,
11199                                 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
11200                                 dext_rec->objectid,
11201                                 dext_rec->offset,
11202                                 dext_rec->length);
11203                 if (!ret)
11204                         ret = 1;
11205         }
11206         return ret;
11207 }
11208
11209
11210 static int check_device_used(struct device_record *dev_rec,
11211                              struct device_extent_tree *dext_cache)
11212 {
11213         struct cache_extent *cache;
11214         struct device_extent_record *dev_extent_rec;
11215         u64 total_byte = 0;
11216
11217         cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
11218         while (cache) {
11219                 dev_extent_rec = container_of(cache,
11220                                               struct device_extent_record,
11221                                               cache);
11222                 if (dev_extent_rec->objectid != dev_rec->devid)
11223                         break;
11224
11225                 list_del_init(&dev_extent_rec->device_list);
11226                 total_byte += dev_extent_rec->length;
11227                 cache = next_cache_extent(cache);
11228         }
11229
11230         if (total_byte != dev_rec->byte_used) {
11231                 fprintf(stderr,
11232                         "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
11233                         total_byte, dev_rec->byte_used, dev_rec->objectid,
11234                         dev_rec->type, dev_rec->offset);
11235                 return -1;
11236         } else {
11237                 return 0;
11238         }
11239 }
11240
11241 /* check btrfs_dev_item -> btrfs_dev_extent */
11242 static int check_devices(struct rb_root *dev_cache,
11243                          struct device_extent_tree *dev_extent_cache)
11244 {
11245         struct rb_node *dev_node;
11246         struct device_record *dev_rec;
11247         struct device_extent_record *dext_rec;
11248         int err;
11249         int ret = 0;
11250
11251         dev_node = rb_first(dev_cache);
11252         while (dev_node) {
11253                 dev_rec = container_of(dev_node, struct device_record, node);
11254                 err = check_device_used(dev_rec, dev_extent_cache);
11255                 if (err)
11256                         ret = err;
11257
11258                 dev_node = rb_next(dev_node);
11259         }
11260         list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
11261                             device_list) {
11262                 fprintf(stderr,
11263                         "Device extent[%llu, %llu, %llu] didn't find its device.\n",
11264                         dext_rec->objectid, dext_rec->offset, dext_rec->length);
11265                 if (!ret)
11266                         ret = 1;
11267         }
11268         return ret;
11269 }
11270
11271 static int add_root_item_to_list(struct list_head *head,
11272                                   u64 objectid, u64 bytenr, u64 last_snapshot,
11273                                   u8 level, u8 drop_level,
11274                                   struct btrfs_key *drop_key)
11275 {
11276
11277         struct root_item_record *ri_rec;
11278         ri_rec = malloc(sizeof(*ri_rec));
11279         if (!ri_rec)
11280                 return -ENOMEM;
11281         ri_rec->bytenr = bytenr;
11282         ri_rec->objectid = objectid;
11283         ri_rec->level = level;
11284         ri_rec->drop_level = drop_level;
11285         ri_rec->last_snapshot = last_snapshot;
11286         if (drop_key)
11287                 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
11288         list_add_tail(&ri_rec->list, head);
11289
11290         return 0;
11291 }
11292
11293 static void free_root_item_list(struct list_head *list)
11294 {
11295         struct root_item_record *ri_rec;
11296
11297         while (!list_empty(list)) {
11298                 ri_rec = list_first_entry(list, struct root_item_record,
11299                                           list);
11300                 list_del_init(&ri_rec->list);
11301                 free(ri_rec);
11302         }
11303 }
11304
11305 static int deal_root_from_list(struct list_head *list,
11306                                struct btrfs_root *root,
11307                                struct block_info *bits,
11308                                int bits_nr,
11309                                struct cache_tree *pending,
11310                                struct cache_tree *seen,
11311                                struct cache_tree *reada,
11312                                struct cache_tree *nodes,
11313                                struct cache_tree *extent_cache,
11314                                struct cache_tree *chunk_cache,
11315                                struct rb_root *dev_cache,
11316                                struct block_group_tree *block_group_cache,
11317                                struct device_extent_tree *dev_extent_cache)
11318 {
11319         int ret = 0;
11320         u64 last;
11321
11322         while (!list_empty(list)) {
11323                 struct root_item_record *rec;
11324                 struct extent_buffer *buf;
11325                 rec = list_entry(list->next,
11326                                  struct root_item_record, list);
11327                 last = 0;
11328                 buf = read_tree_block(root->fs_info, rec->bytenr, 0);
11329                 if (!extent_buffer_uptodate(buf)) {
11330                         free_extent_buffer(buf);
11331                         ret = -EIO;
11332                         break;
11333                 }
11334                 ret = add_root_to_pending(buf, extent_cache, pending,
11335                                     seen, nodes, rec->objectid);
11336                 if (ret < 0)
11337                         break;
11338                 /*
11339                  * To rebuild extent tree, we need deal with snapshot
11340                  * one by one, otherwise we deal with node firstly which
11341                  * can maximize readahead.
11342                  */
11343                 while (1) {
11344                         ret = run_next_block(root, bits, bits_nr, &last,
11345                                              pending, seen, reada, nodes,
11346                                              extent_cache, chunk_cache,
11347                                              dev_cache, block_group_cache,
11348                                              dev_extent_cache, rec);
11349                         if (ret != 0)
11350                                 break;
11351                 }
11352                 free_extent_buffer(buf);
11353                 list_del(&rec->list);
11354                 free(rec);
11355                 if (ret < 0)
11356                         break;
11357         }
11358         while (ret >= 0) {
11359                 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
11360                                      reada, nodes, extent_cache, chunk_cache,
11361                                      dev_cache, block_group_cache,
11362                                      dev_extent_cache, NULL);
11363                 if (ret != 0) {
11364                         if (ret > 0)
11365                                 ret = 0;
11366                         break;
11367                 }
11368         }
11369         return ret;
11370 }
11371
11372 static int check_chunks_and_extents(struct btrfs_fs_info *fs_info)
11373 {
11374         struct rb_root dev_cache;
11375         struct cache_tree chunk_cache;
11376         struct block_group_tree block_group_cache;
11377         struct device_extent_tree dev_extent_cache;
11378         struct cache_tree extent_cache;
11379         struct cache_tree seen;
11380         struct cache_tree pending;
11381         struct cache_tree reada;
11382         struct cache_tree nodes;
11383         struct extent_io_tree excluded_extents;
11384         struct cache_tree corrupt_blocks;
11385         struct btrfs_path path;
11386         struct btrfs_key key;
11387         struct btrfs_key found_key;
11388         int ret, err = 0;
11389         struct block_info *bits;
11390         int bits_nr;
11391         struct extent_buffer *leaf;
11392         int slot;
11393         struct btrfs_root_item ri;
11394         struct list_head dropping_trees;
11395         struct list_head normal_trees;
11396         struct btrfs_root *root1;
11397         struct btrfs_root *root;
11398         u64 objectid;
11399         u8 level;
11400
11401         root = fs_info->fs_root;
11402         dev_cache = RB_ROOT;
11403         cache_tree_init(&chunk_cache);
11404         block_group_tree_init(&block_group_cache);
11405         device_extent_tree_init(&dev_extent_cache);
11406
11407         cache_tree_init(&extent_cache);
11408         cache_tree_init(&seen);
11409         cache_tree_init(&pending);
11410         cache_tree_init(&nodes);
11411         cache_tree_init(&reada);
11412         cache_tree_init(&corrupt_blocks);
11413         extent_io_tree_init(&excluded_extents);
11414         INIT_LIST_HEAD(&dropping_trees);
11415         INIT_LIST_HEAD(&normal_trees);
11416
11417         if (repair) {
11418                 fs_info->excluded_extents = &excluded_extents;
11419                 fs_info->fsck_extent_cache = &extent_cache;
11420                 fs_info->free_extent_hook = free_extent_hook;
11421                 fs_info->corrupt_blocks = &corrupt_blocks;
11422         }
11423
11424         bits_nr = 1024;
11425         bits = malloc(bits_nr * sizeof(struct block_info));
11426         if (!bits) {
11427                 perror("malloc");
11428                 exit(1);
11429         }
11430
11431         if (ctx.progress_enabled) {
11432                 ctx.tp = TASK_EXTENTS;
11433                 task_start(ctx.info);
11434         }
11435
11436 again:
11437         root1 = fs_info->tree_root;
11438         level = btrfs_header_level(root1->node);
11439         ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
11440                                     root1->node->start, 0, level, 0, NULL);
11441         if (ret < 0)
11442                 goto out;
11443         root1 = fs_info->chunk_root;
11444         level = btrfs_header_level(root1->node);
11445         ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
11446                                     root1->node->start, 0, level, 0, NULL);
11447         if (ret < 0)
11448                 goto out;
11449         btrfs_init_path(&path);
11450         key.offset = 0;
11451         key.objectid = 0;
11452         key.type = BTRFS_ROOT_ITEM_KEY;
11453         ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, &path, 0, 0);
11454         if (ret < 0)
11455                 goto out;
11456         while(1) {
11457                 leaf = path.nodes[0];
11458                 slot = path.slots[0];
11459                 if (slot >= btrfs_header_nritems(path.nodes[0])) {
11460                         ret = btrfs_next_leaf(root, &path);
11461                         if (ret != 0)
11462                                 break;
11463                         leaf = path.nodes[0];
11464                         slot = path.slots[0];
11465                 }
11466                 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
11467                 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
11468                         unsigned long offset;
11469                         u64 last_snapshot;
11470
11471                         offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
11472                         read_extent_buffer(leaf, &ri, offset, sizeof(ri));
11473                         last_snapshot = btrfs_root_last_snapshot(&ri);
11474                         if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
11475                                 level = btrfs_root_level(&ri);
11476                                 ret = add_root_item_to_list(&normal_trees,
11477                                                 found_key.objectid,
11478                                                 btrfs_root_bytenr(&ri),
11479                                                 last_snapshot, level,
11480                                                 0, NULL);
11481                                 if (ret < 0)
11482                                         goto out;
11483                         } else {
11484                                 level = btrfs_root_level(&ri);
11485                                 objectid = found_key.objectid;
11486                                 btrfs_disk_key_to_cpu(&found_key,
11487                                                       &ri.drop_progress);
11488                                 ret = add_root_item_to_list(&dropping_trees,
11489                                                 objectid,
11490                                                 btrfs_root_bytenr(&ri),
11491                                                 last_snapshot, level,
11492                                                 ri.drop_level, &found_key);
11493                                 if (ret < 0)
11494                                         goto out;
11495                         }
11496                 }
11497                 path.slots[0]++;
11498         }
11499         btrfs_release_path(&path);
11500
11501         /*
11502          * check_block can return -EAGAIN if it fixes something, please keep
11503          * this in mind when dealing with return values from these functions, if
11504          * we get -EAGAIN we want to fall through and restart the loop.
11505          */
11506         ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
11507                                   &seen, &reada, &nodes, &extent_cache,
11508                                   &chunk_cache, &dev_cache, &block_group_cache,
11509                                   &dev_extent_cache);
11510         if (ret < 0) {
11511                 if (ret == -EAGAIN)
11512                         goto loop;
11513                 goto out;
11514         }
11515         ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
11516                                   &pending, &seen, &reada, &nodes,
11517                                   &extent_cache, &chunk_cache, &dev_cache,
11518                                   &block_group_cache, &dev_extent_cache);
11519         if (ret < 0) {
11520                 if (ret == -EAGAIN)
11521                         goto loop;
11522                 goto out;
11523         }
11524
11525         ret = check_chunks(&chunk_cache, &block_group_cache,
11526                            &dev_extent_cache, NULL, NULL, NULL, 0);
11527         if (ret) {
11528                 if (ret == -EAGAIN)
11529                         goto loop;
11530                 err = ret;
11531         }
11532
11533         ret = check_extent_refs(root, &extent_cache);
11534         if (ret < 0) {
11535                 if (ret == -EAGAIN)
11536                         goto loop;
11537                 goto out;
11538         }
11539
11540         ret = check_devices(&dev_cache, &dev_extent_cache);
11541         if (ret && err)
11542                 ret = err;
11543
11544 out:
11545         task_stop(ctx.info);
11546         if (repair) {
11547                 free_corrupt_blocks_tree(fs_info->corrupt_blocks);
11548                 extent_io_tree_cleanup(&excluded_extents);
11549                 fs_info->fsck_extent_cache = NULL;
11550                 fs_info->free_extent_hook = NULL;
11551                 fs_info->corrupt_blocks = NULL;
11552                 fs_info->excluded_extents = NULL;
11553         }
11554         free(bits);
11555         free_chunk_cache_tree(&chunk_cache);
11556         free_device_cache_tree(&dev_cache);
11557         free_block_group_tree(&block_group_cache);
11558         free_device_extent_tree(&dev_extent_cache);
11559         free_extent_cache_tree(&seen);
11560         free_extent_cache_tree(&pending);
11561         free_extent_cache_tree(&reada);
11562         free_extent_cache_tree(&nodes);
11563         free_root_item_list(&normal_trees);
11564         free_root_item_list(&dropping_trees);
11565         return ret;
11566 loop:
11567         free_corrupt_blocks_tree(fs_info->corrupt_blocks);
11568         free_extent_cache_tree(&seen);
11569         free_extent_cache_tree(&pending);
11570         free_extent_cache_tree(&reada);
11571         free_extent_cache_tree(&nodes);
11572         free_chunk_cache_tree(&chunk_cache);
11573         free_block_group_tree(&block_group_cache);
11574         free_device_cache_tree(&dev_cache);
11575         free_device_extent_tree(&dev_extent_cache);
11576         free_extent_record_cache(&extent_cache);
11577         free_root_item_list(&normal_trees);
11578         free_root_item_list(&dropping_trees);
11579         extent_io_tree_cleanup(&excluded_extents);
11580         goto again;
11581 }
11582
11583 static int check_extent_inline_ref(struct extent_buffer *eb,
11584                    struct btrfs_key *key, struct btrfs_extent_inline_ref *iref)
11585 {
11586         int ret;
11587         u8 type = btrfs_extent_inline_ref_type(eb, iref);
11588
11589         switch (type) {
11590         case BTRFS_TREE_BLOCK_REF_KEY:
11591         case BTRFS_EXTENT_DATA_REF_KEY:
11592         case BTRFS_SHARED_BLOCK_REF_KEY:
11593         case BTRFS_SHARED_DATA_REF_KEY:
11594                 ret = 0;
11595                 break;
11596         default:
11597                 error("extent[%llu %u %llu] has unknown ref type: %d",
11598                       key->objectid, key->type, key->offset, type);
11599                 ret = UNKNOWN_TYPE;
11600                 break;
11601         }
11602
11603         return ret;
11604 }
11605
11606 /*
11607  * Check backrefs of a tree block given by @bytenr or @eb.
11608  *
11609  * @root:       the root containing the @bytenr or @eb
11610  * @eb:         tree block extent buffer, can be NULL
11611  * @bytenr:     bytenr of the tree block to search
11612  * @level:      tree level of the tree block
11613  * @owner:      owner of the tree block
11614  *
11615  * Return >0 for any error found and output error message
11616  * Return 0 for no error found
11617  */
11618 static int check_tree_block_ref(struct btrfs_root *root,
11619                                 struct extent_buffer *eb, u64 bytenr,
11620                                 int level, u64 owner, struct node_refs *nrefs)
11621 {
11622         struct btrfs_key key;
11623         struct btrfs_root *extent_root = root->fs_info->extent_root;
11624         struct btrfs_path path;
11625         struct btrfs_extent_item *ei;
11626         struct btrfs_extent_inline_ref *iref;
11627         struct extent_buffer *leaf;
11628         unsigned long end;
11629         unsigned long ptr;
11630         int slot;
11631         int skinny_level;
11632         int root_level = btrfs_header_level(root->node);
11633         int type;
11634         u32 nodesize = root->fs_info->nodesize;
11635         u32 item_size;
11636         u64 offset;
11637         int tree_reloc_root = 0;
11638         int found_ref = 0;
11639         int err = 0;
11640         int ret;
11641         int strict = 1;
11642         int parent = 0;
11643
11644         if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
11645             btrfs_header_bytenr(root->node) == bytenr)
11646                 tree_reloc_root = 1;
11647         btrfs_init_path(&path);
11648         key.objectid = bytenr;
11649         if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
11650                 key.type = BTRFS_METADATA_ITEM_KEY;
11651         else
11652                 key.type = BTRFS_EXTENT_ITEM_KEY;
11653         key.offset = (u64)-1;
11654
11655         /* Search for the backref in extent tree */
11656         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11657         if (ret < 0) {
11658                 err |= BACKREF_MISSING;
11659                 goto out;
11660         }
11661         ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
11662         if (ret) {
11663                 err |= BACKREF_MISSING;
11664                 goto out;
11665         }
11666
11667         leaf = path.nodes[0];
11668         slot = path.slots[0];
11669         btrfs_item_key_to_cpu(leaf, &key, slot);
11670
11671         ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11672
11673         if (key.type == BTRFS_METADATA_ITEM_KEY) {
11674                 skinny_level = (int)key.offset;
11675                 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11676         } else {
11677                 struct btrfs_tree_block_info *info;
11678
11679                 info = (struct btrfs_tree_block_info *)(ei + 1);
11680                 skinny_level = btrfs_tree_block_level(leaf, info);
11681                 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11682         }
11683
11684
11685         if (eb) {
11686                 u64 header_gen;
11687                 u64 extent_gen;
11688
11689                 /*
11690                  * Due to the feature of shared tree blocks, if the upper node
11691                  * is a fs root or shared node, the extent of checked node may
11692                  * not be updated until the next CoW.
11693                  */
11694                 if (nrefs)
11695                         strict = should_check_extent_strictly(root, nrefs,
11696                                         level);
11697                 if (!(btrfs_extent_flags(leaf, ei) &
11698                       BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
11699                         error(
11700                 "extent[%llu %u] backref type mismatch, missing bit: %llx",
11701                                 key.objectid, nodesize,
11702                                 BTRFS_EXTENT_FLAG_TREE_BLOCK);
11703                         err = BACKREF_MISMATCH;
11704                 }
11705                 header_gen = btrfs_header_generation(eb);
11706                 extent_gen = btrfs_extent_generation(leaf, ei);
11707                 if (header_gen != extent_gen) {
11708                         error(
11709         "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
11710                                 key.objectid, nodesize, header_gen,
11711                                 extent_gen);
11712                         err = BACKREF_MISMATCH;
11713                 }
11714                 if (level != skinny_level) {
11715                         error(
11716                         "extent[%llu %u] level mismatch, wanted: %u, have: %u",
11717                                 key.objectid, nodesize, level, skinny_level);
11718                         err = BACKREF_MISMATCH;
11719                 }
11720                 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
11721                         error(
11722                         "extent[%llu %u] is referred by other roots than %llu",
11723                                 key.objectid, nodesize, root->objectid);
11724                         err = BACKREF_MISMATCH;
11725                 }
11726         }
11727
11728         /*
11729          * Iterate the extent/metadata item to find the exact backref
11730          */
11731         item_size = btrfs_item_size_nr(leaf, slot);
11732         ptr = (unsigned long)iref;
11733         end = (unsigned long)ei + item_size;
11734
11735         while (ptr < end) {
11736                 iref = (struct btrfs_extent_inline_ref *)ptr;
11737                 type = btrfs_extent_inline_ref_type(leaf, iref);
11738                 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11739
11740                 ret = check_extent_inline_ref(leaf, &key, iref);
11741                 if (ret) {
11742                         err |= ret;
11743                         break;
11744                 }
11745                 if (type == BTRFS_TREE_BLOCK_REF_KEY) {
11746                         if (offset == root->objectid)
11747                                 found_ref = 1;
11748                         if (!strict && owner == offset)
11749                                 found_ref = 1;
11750                 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
11751                         /*
11752                          * Backref of tree reloc root points to itself, no need
11753                          * to check backref any more.
11754                          */
11755                         if (tree_reloc_root) {
11756                                 found_ref = 1;
11757                         } else {
11758                                 /*
11759                                  * Check if the backref points to valid
11760                                  * referencer
11761                                  */
11762                                 found_ref = !check_tree_block_ref( root, NULL,
11763                                                 offset, level + 1, owner,
11764                                                 NULL);
11765                         }
11766                 }
11767
11768                 if (found_ref)
11769                         break;
11770                 ptr += btrfs_extent_inline_ref_size(type);
11771         }
11772
11773         /*
11774          * Inlined extent item doesn't have what we need, check
11775          * TREE_BLOCK_REF_KEY
11776          */
11777         if (!found_ref) {
11778                 btrfs_release_path(&path);
11779                 key.objectid = bytenr;
11780                 key.type = BTRFS_TREE_BLOCK_REF_KEY;
11781                 key.offset = root->objectid;
11782
11783                 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11784                 if (!ret)
11785                         found_ref = 1;
11786         }
11787         if (!found_ref)
11788                 err |= BACKREF_MISSING;
11789 out:
11790         btrfs_release_path(&path);
11791         if (nrefs && strict &&
11792             level < root_level && nrefs->full_backref[level + 1])
11793                 parent = nrefs->bytenr[level + 1];
11794         if (eb && (err & BACKREF_MISSING))
11795                 error(
11796         "extent[%llu %u] backref lost (owner: %llu, level: %u) %s %llu",
11797                       bytenr, nodesize, owner, level,
11798                       parent ? "parent" : "root",
11799                       parent ? parent : root->objectid);
11800         return err;
11801 }
11802
11803 /*
11804  * If @err contains BACKREF_MISSING then add extent of the
11805  * file_extent_data_item.
11806  *
11807  * Returns error bits after reapir.
11808  */
11809 static int repair_extent_data_item(struct btrfs_trans_handle *trans,
11810                                    struct btrfs_root *root,
11811                                    struct btrfs_path *pathp,
11812                                    struct node_refs *nrefs,
11813                                    int err)
11814 {
11815         struct btrfs_file_extent_item *fi;
11816         struct btrfs_key fi_key;
11817         struct btrfs_key key;
11818         struct btrfs_extent_item *ei;
11819         struct btrfs_path path;
11820         struct btrfs_root *extent_root = root->fs_info->extent_root;
11821         struct extent_buffer *eb;
11822         u64 size;
11823         u64 disk_bytenr;
11824         u64 num_bytes;
11825         u64 parent;
11826         u64 offset;
11827         u64 extent_offset;
11828         u64 file_offset;
11829         int generation;
11830         int slot;
11831         int ret = 0;
11832
11833         eb = pathp->nodes[0];
11834         slot = pathp->slots[0];
11835         btrfs_item_key_to_cpu(eb, &fi_key, slot);
11836         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
11837
11838         if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
11839             btrfs_file_extent_disk_bytenr(eb, fi) == 0)
11840                 return err;
11841
11842         file_offset = fi_key.offset;
11843         generation = btrfs_file_extent_generation(eb, fi);
11844         disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
11845         num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
11846         extent_offset = btrfs_file_extent_offset(eb, fi);
11847         offset = file_offset - extent_offset;
11848
11849         /* now repair only adds backref */
11850         if ((err & BACKREF_MISSING) == 0)
11851                 return err;
11852
11853         /* search extent item */
11854         key.objectid = disk_bytenr;
11855         key.type = BTRFS_EXTENT_ITEM_KEY;
11856         key.offset = num_bytes;
11857
11858         btrfs_init_path(&path);
11859         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11860         if (ret < 0) {
11861                 ret = -EIO;
11862                 goto out;
11863         }
11864
11865         /* insert an extent item */
11866         if (ret > 0) {
11867                 key.objectid = disk_bytenr;
11868                 key.type = BTRFS_EXTENT_ITEM_KEY;
11869                 key.offset = num_bytes;
11870                 size = sizeof(*ei);
11871
11872                 btrfs_release_path(&path);
11873                 ret = btrfs_insert_empty_item(trans, extent_root, &path, &key,
11874                                               size);
11875                 if (ret)
11876                         goto out;
11877                 eb = path.nodes[0];
11878                 ei = btrfs_item_ptr(eb, path.slots[0], struct btrfs_extent_item);
11879
11880                 btrfs_set_extent_refs(eb, ei, 0);
11881                 btrfs_set_extent_generation(eb, ei, generation);
11882                 btrfs_set_extent_flags(eb, ei, BTRFS_EXTENT_FLAG_DATA);
11883
11884                 btrfs_mark_buffer_dirty(eb);
11885                 ret = btrfs_update_block_group(trans, extent_root, disk_bytenr,
11886                                                num_bytes, 1, 0);
11887                 btrfs_release_path(&path);
11888         }
11889
11890         if (nrefs->full_backref[0])
11891                 parent = btrfs_header_bytenr(eb);
11892         else
11893                 parent = 0;
11894
11895         ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, parent,
11896                                    root->objectid,
11897                    parent ? BTRFS_FIRST_FREE_OBJECTID : fi_key.objectid,
11898                                    offset);
11899         if (ret) {
11900                 error(
11901                 "failed to increase extent data backref[%llu %llu] root %llu",
11902                       disk_bytenr, num_bytes, root->objectid);
11903                 goto out;
11904         } else {
11905                 printf("Add one extent data backref [%llu %llu]\n",
11906                        disk_bytenr, num_bytes);
11907         }
11908
11909         err &= ~BACKREF_MISSING;
11910 out:
11911         if (ret)
11912                 error("can't repair root %llu extent data item[%llu %llu]",
11913                       root->objectid, disk_bytenr, num_bytes);
11914         return err;
11915 }
11916
11917 /*
11918  * Check EXTENT_DATA item, mainly for its dbackref in extent tree
11919  *
11920  * Return >0 any error found and output error message
11921  * Return 0 for no error found
11922  */
11923 static int check_extent_data_item(struct btrfs_root *root,
11924                                   struct btrfs_path *pathp,
11925                                   struct node_refs *nrefs,  int account_bytes)
11926 {
11927         struct btrfs_file_extent_item *fi;
11928         struct extent_buffer *eb = pathp->nodes[0];
11929         struct btrfs_path path;
11930         struct btrfs_root *extent_root = root->fs_info->extent_root;
11931         struct btrfs_key fi_key;
11932         struct btrfs_key dbref_key;
11933         struct extent_buffer *leaf;
11934         struct btrfs_extent_item *ei;
11935         struct btrfs_extent_inline_ref *iref;
11936         struct btrfs_extent_data_ref *dref;
11937         u64 owner;
11938         u64 disk_bytenr;
11939         u64 disk_num_bytes;
11940         u64 extent_num_bytes;
11941         u64 extent_flags;
11942         u32 item_size;
11943         unsigned long end;
11944         unsigned long ptr;
11945         int type;
11946         u64 ref_root;
11947         int found_dbackref = 0;
11948         int slot = pathp->slots[0];
11949         int err = 0;
11950         int ret;
11951         int strict;
11952
11953         btrfs_item_key_to_cpu(eb, &fi_key, slot);
11954         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
11955
11956         /* Nothing to check for hole and inline data extents */
11957         if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
11958             btrfs_file_extent_disk_bytenr(eb, fi) == 0)
11959                 return 0;
11960
11961         disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
11962         disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
11963         extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
11964
11965         /* Check unaligned disk_num_bytes and num_bytes */
11966         if (!IS_ALIGNED(disk_num_bytes, root->fs_info->sectorsize)) {
11967                 error(
11968 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
11969                         fi_key.objectid, fi_key.offset, disk_num_bytes,
11970                         root->fs_info->sectorsize);
11971                 err |= BYTES_UNALIGNED;
11972         } else if (account_bytes) {
11973                 data_bytes_allocated += disk_num_bytes;
11974         }
11975         if (!IS_ALIGNED(extent_num_bytes, root->fs_info->sectorsize)) {
11976                 error(
11977 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
11978                         fi_key.objectid, fi_key.offset, extent_num_bytes,
11979                         root->fs_info->sectorsize);
11980                 err |= BYTES_UNALIGNED;
11981         } else if (account_bytes) {
11982                 data_bytes_referenced += extent_num_bytes;
11983         }
11984         owner = btrfs_header_owner(eb);
11985
11986         /* Check the extent item of the file extent in extent tree */
11987         btrfs_init_path(&path);
11988         dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
11989         dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
11990         dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
11991
11992         ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
11993         if (ret)
11994                 goto out;
11995
11996         leaf = path.nodes[0];
11997         slot = path.slots[0];
11998         ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11999
12000         extent_flags = btrfs_extent_flags(leaf, ei);
12001
12002         if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
12003                 error(
12004                     "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
12005                     disk_bytenr, disk_num_bytes,
12006                     BTRFS_EXTENT_FLAG_DATA);
12007                 err |= BACKREF_MISMATCH;
12008         }
12009
12010         /* Check data backref inside that extent item */
12011         item_size = btrfs_item_size_nr(leaf, path.slots[0]);
12012         iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12013         ptr = (unsigned long)iref;
12014         end = (unsigned long)ei + item_size;
12015         strict = should_check_extent_strictly(root, nrefs, -1);
12016
12017         while (ptr < end) {
12018                 iref = (struct btrfs_extent_inline_ref *)ptr;
12019                 type = btrfs_extent_inline_ref_type(leaf, iref);
12020                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
12021
12022                 ret = check_extent_inline_ref(leaf, &dbref_key, iref);
12023                 if (ret) {
12024                         err |= ret;
12025                         break;
12026                 }
12027                 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
12028                         ref_root = btrfs_extent_data_ref_root(leaf, dref);
12029                         if (ref_root == root->objectid)
12030                                 found_dbackref = 1;
12031                         else if (!strict && owner == ref_root)
12032                                 found_dbackref = 1;
12033                 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
12034                         found_dbackref = !check_tree_block_ref(root, NULL,
12035                                 btrfs_extent_inline_ref_offset(leaf, iref),
12036                                 0, owner, NULL);
12037                 }
12038
12039                 if (found_dbackref)
12040                         break;
12041                 ptr += btrfs_extent_inline_ref_size(type);
12042         }
12043
12044         if (!found_dbackref) {
12045                 btrfs_release_path(&path);
12046
12047                 /* Didn't find inlined data backref, try EXTENT_DATA_REF_KEY */
12048                 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
12049                 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
12050                 dbref_key.offset = hash_extent_data_ref(root->objectid,
12051                                 fi_key.objectid, fi_key.offset);
12052
12053                 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
12054                                         &dbref_key, &path, 0, 0);
12055                 if (!ret) {
12056                         found_dbackref = 1;
12057                         goto out;
12058                 }
12059
12060                 btrfs_release_path(&path);
12061
12062                 /*
12063                  * Neither inlined nor EXTENT_DATA_REF found, try
12064                  * SHARED_DATA_REF as last chance.
12065                  */
12066                 dbref_key.objectid = disk_bytenr;
12067                 dbref_key.type = BTRFS_SHARED_DATA_REF_KEY;
12068                 dbref_key.offset = eb->start;
12069
12070                 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
12071                                         &dbref_key, &path, 0, 0);
12072                 if (!ret) {
12073                         found_dbackref = 1;
12074                         goto out;
12075                 }
12076         }
12077
12078 out:
12079         if (!found_dbackref)
12080                 err |= BACKREF_MISSING;
12081         btrfs_release_path(&path);
12082         if (err & BACKREF_MISSING) {
12083                 error("data extent[%llu %llu] backref lost",
12084                       disk_bytenr, disk_num_bytes);
12085         }
12086         return err;
12087 }
12088
12089 /*
12090  * Get real tree block level for the case like shared block
12091  * Return >= 0 as tree level
12092  * Return <0 for error
12093  */
12094 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
12095 {
12096         struct extent_buffer *eb;
12097         struct btrfs_path path;
12098         struct btrfs_key key;
12099         struct btrfs_extent_item *ei;
12100         u64 flags;
12101         u64 transid;
12102         u8 backref_level;
12103         u8 header_level;
12104         int ret;
12105
12106         /* Search extent tree for extent generation and level */
12107         key.objectid = bytenr;
12108         key.type = BTRFS_METADATA_ITEM_KEY;
12109         key.offset = (u64)-1;
12110
12111         btrfs_init_path(&path);
12112         ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
12113         if (ret < 0)
12114                 goto release_out;
12115         ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
12116         if (ret < 0)
12117                 goto release_out;
12118         if (ret > 0) {
12119                 ret = -ENOENT;
12120                 goto release_out;
12121         }
12122
12123         btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12124         ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
12125                             struct btrfs_extent_item);
12126         flags = btrfs_extent_flags(path.nodes[0], ei);
12127         if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
12128                 ret = -ENOENT;
12129                 goto release_out;
12130         }
12131
12132         /* Get transid for later read_tree_block() check */
12133         transid = btrfs_extent_generation(path.nodes[0], ei);
12134
12135         /* Get backref level as one source */
12136         if (key.type == BTRFS_METADATA_ITEM_KEY) {
12137                 backref_level = key.offset;
12138         } else {
12139                 struct btrfs_tree_block_info *info;
12140
12141                 info = (struct btrfs_tree_block_info *)(ei + 1);
12142                 backref_level = btrfs_tree_block_level(path.nodes[0], info);
12143         }
12144         btrfs_release_path(&path);
12145
12146         /* Get level from tree block as an alternative source */
12147         eb = read_tree_block(fs_info, bytenr, transid);
12148         if (!extent_buffer_uptodate(eb)) {
12149                 free_extent_buffer(eb);
12150                 return -EIO;
12151         }
12152         header_level = btrfs_header_level(eb);
12153         free_extent_buffer(eb);
12154
12155         if (header_level != backref_level)
12156                 return -EIO;
12157         return header_level;
12158
12159 release_out:
12160         btrfs_release_path(&path);
12161         return ret;
12162 }
12163
12164 /*
12165  * Check if a tree block backref is valid (points to a valid tree block)
12166  * if level == -1, level will be resolved
12167  * Return >0 for any error found and print error message
12168  */
12169 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
12170                                     u64 bytenr, int level)
12171 {
12172         struct btrfs_root *root;
12173         struct btrfs_key key;
12174         struct btrfs_path path;
12175         struct extent_buffer *eb;
12176         struct extent_buffer *node;
12177         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
12178         int err = 0;
12179         int ret;
12180
12181         /* Query level for level == -1 special case */
12182         if (level == -1)
12183                 level = query_tree_block_level(fs_info, bytenr);
12184         if (level < 0) {
12185                 err |= REFERENCER_MISSING;
12186                 goto out;
12187         }
12188
12189         key.objectid = root_id;
12190         key.type = BTRFS_ROOT_ITEM_KEY;
12191         key.offset = (u64)-1;
12192
12193         root = btrfs_read_fs_root(fs_info, &key);
12194         if (IS_ERR(root)) {
12195                 err |= REFERENCER_MISSING;
12196                 goto out;
12197         }
12198
12199         /* Read out the tree block to get item/node key */
12200         eb = read_tree_block(fs_info, bytenr, 0);
12201         if (!extent_buffer_uptodate(eb)) {
12202                 err |= REFERENCER_MISSING;
12203                 free_extent_buffer(eb);
12204                 goto out;
12205         }
12206
12207         /* Empty tree, no need to check key */
12208         if (!btrfs_header_nritems(eb) && !level) {
12209                 free_extent_buffer(eb);
12210                 goto out;
12211         }
12212
12213         if (level)
12214                 btrfs_node_key_to_cpu(eb, &key, 0);
12215         else
12216                 btrfs_item_key_to_cpu(eb, &key, 0);
12217
12218         free_extent_buffer(eb);
12219
12220         btrfs_init_path(&path);
12221         path.lowest_level = level;
12222         /* Search with the first key, to ensure we can reach it */
12223         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
12224         if (ret < 0) {
12225                 err |= REFERENCER_MISSING;
12226                 goto release_out;
12227         }
12228
12229         node = path.nodes[level];
12230         if (btrfs_header_bytenr(node) != bytenr) {
12231                 error(
12232         "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
12233                         bytenr, nodesize, bytenr,
12234                         btrfs_header_bytenr(node));
12235                 err |= REFERENCER_MISMATCH;
12236         }
12237         if (btrfs_header_level(node) != level) {
12238                 error(
12239         "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
12240                         bytenr, nodesize, level,
12241                         btrfs_header_level(node));
12242                 err |= REFERENCER_MISMATCH;
12243         }
12244
12245 release_out:
12246         btrfs_release_path(&path);
12247 out:
12248         if (err & REFERENCER_MISSING) {
12249                 if (level < 0)
12250                         error("extent [%llu %d] lost referencer (owner: %llu)",
12251                                 bytenr, nodesize, root_id);
12252                 else
12253                         error(
12254                 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
12255                                 bytenr, nodesize, root_id, level);
12256         }
12257
12258         return err;
12259 }
12260
12261 /*
12262  * Check if tree block @eb is tree reloc root.
12263  * Return 0 if it's not or any problem happens
12264  * Return 1 if it's a tree reloc root
12265  */
12266 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
12267                                  struct extent_buffer *eb)
12268 {
12269         struct btrfs_root *tree_reloc_root;
12270         struct btrfs_key key;
12271         u64 bytenr = btrfs_header_bytenr(eb);
12272         u64 owner = btrfs_header_owner(eb);
12273         int ret = 0;
12274
12275         key.objectid = BTRFS_TREE_RELOC_OBJECTID;
12276         key.offset = owner;
12277         key.type = BTRFS_ROOT_ITEM_KEY;
12278
12279         tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
12280         if (IS_ERR(tree_reloc_root))
12281                 return 0;
12282
12283         if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
12284                 ret = 1;
12285         btrfs_free_fs_root(tree_reloc_root);
12286         return ret;
12287 }
12288
12289 /*
12290  * Check referencer for shared block backref
12291  * If level == -1, this function will resolve the level.
12292  */
12293 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
12294                                      u64 parent, u64 bytenr, int level)
12295 {
12296         struct extent_buffer *eb;
12297         u32 nr;
12298         int found_parent = 0;
12299         int i;
12300
12301         eb = read_tree_block(fs_info, parent, 0);
12302         if (!extent_buffer_uptodate(eb))
12303                 goto out;
12304
12305         if (level == -1)
12306                 level = query_tree_block_level(fs_info, bytenr);
12307         if (level < 0)
12308                 goto out;
12309
12310         /* It's possible it's a tree reloc root */
12311         if (parent == bytenr) {
12312                 if (is_tree_reloc_root(fs_info, eb))
12313                         found_parent = 1;
12314                 goto out;
12315         }
12316
12317         if (level + 1 != btrfs_header_level(eb))
12318                 goto out;
12319
12320         nr = btrfs_header_nritems(eb);
12321         for (i = 0; i < nr; i++) {
12322                 if (bytenr == btrfs_node_blockptr(eb, i)) {
12323                         found_parent = 1;
12324                         break;
12325                 }
12326         }
12327 out:
12328         free_extent_buffer(eb);
12329         if (!found_parent) {
12330                 error(
12331         "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
12332                         bytenr, fs_info->nodesize, parent, level);
12333                 return REFERENCER_MISSING;
12334         }
12335         return 0;
12336 }
12337
12338 /*
12339  * Check referencer for normal (inlined) data ref
12340  * If len == 0, it will be resolved by searching in extent tree
12341  */
12342 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
12343                                      u64 root_id, u64 objectid, u64 offset,
12344                                      u64 bytenr, u64 len, u32 count)
12345 {
12346         struct btrfs_root *root;
12347         struct btrfs_root *extent_root = fs_info->extent_root;
12348         struct btrfs_key key;
12349         struct btrfs_path path;
12350         struct extent_buffer *leaf;
12351         struct btrfs_file_extent_item *fi;
12352         u32 found_count = 0;
12353         int slot;
12354         int ret = 0;
12355
12356         if (!len) {
12357                 key.objectid = bytenr;
12358                 key.type = BTRFS_EXTENT_ITEM_KEY;
12359                 key.offset = (u64)-1;
12360
12361                 btrfs_init_path(&path);
12362                 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12363                 if (ret < 0)
12364                         goto out;
12365                 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
12366                 if (ret)
12367                         goto out;
12368                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12369                 if (key.objectid != bytenr ||
12370                     key.type != BTRFS_EXTENT_ITEM_KEY)
12371                         goto out;
12372                 len = key.offset;
12373                 btrfs_release_path(&path);
12374         }
12375         key.objectid = root_id;
12376         key.type = BTRFS_ROOT_ITEM_KEY;
12377         key.offset = (u64)-1;
12378         btrfs_init_path(&path);
12379
12380         root = btrfs_read_fs_root(fs_info, &key);
12381         if (IS_ERR(root))
12382                 goto out;
12383
12384         key.objectid = objectid;
12385         key.type = BTRFS_EXTENT_DATA_KEY;
12386         /*
12387          * It can be nasty as data backref offset is
12388          * file offset - file extent offset, which is smaller or
12389          * equal to original backref offset.  The only special case is
12390          * overflow.  So we need to special check and do further search.
12391          */
12392         key.offset = offset & (1ULL << 63) ? 0 : offset;
12393
12394         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
12395         if (ret < 0)
12396                 goto out;
12397
12398         /*
12399          * Search afterwards to get correct one
12400          * NOTE: As we must do a comprehensive check on the data backref to
12401          * make sure the dref count also matches, we must iterate all file
12402          * extents for that inode.
12403          */
12404         while (1) {
12405                 leaf = path.nodes[0];
12406                 slot = path.slots[0];
12407
12408                 if (slot >= btrfs_header_nritems(leaf))
12409                         goto next;
12410                 btrfs_item_key_to_cpu(leaf, &key, slot);
12411                 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
12412                         break;
12413                 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
12414                 /*
12415                  * Except normal disk bytenr and disk num bytes, we still
12416                  * need to do extra check on dbackref offset as
12417                  * dbackref offset = file_offset - file_extent_offset
12418                  */
12419                 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
12420                     btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
12421                     (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
12422                     offset)
12423                         found_count++;
12424
12425 next:
12426                 ret = btrfs_next_item(root, &path);
12427                 if (ret)
12428                         break;
12429         }
12430 out:
12431         btrfs_release_path(&path);
12432         if (found_count != count) {
12433                 error(
12434 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
12435                         bytenr, len, root_id, objectid, offset, count, found_count);
12436                 return REFERENCER_MISSING;
12437         }
12438         return 0;
12439 }
12440
12441 /*
12442  * Check if the referencer of a shared data backref exists
12443  */
12444 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
12445                                      u64 parent, u64 bytenr)
12446 {
12447         struct extent_buffer *eb;
12448         struct btrfs_key key;
12449         struct btrfs_file_extent_item *fi;
12450         u32 nr;
12451         int found_parent = 0;
12452         int i;
12453
12454         eb = read_tree_block(fs_info, parent, 0);
12455         if (!extent_buffer_uptodate(eb))
12456                 goto out;
12457
12458         nr = btrfs_header_nritems(eb);
12459         for (i = 0; i < nr; i++) {
12460                 btrfs_item_key_to_cpu(eb, &key, i);
12461                 if (key.type != BTRFS_EXTENT_DATA_KEY)
12462                         continue;
12463
12464                 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
12465                 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
12466                         continue;
12467
12468                 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
12469                         found_parent = 1;
12470                         break;
12471                 }
12472         }
12473
12474 out:
12475         free_extent_buffer(eb);
12476         if (!found_parent) {
12477                 error("shared extent %llu referencer lost (parent: %llu)",
12478                         bytenr, parent);
12479                 return REFERENCER_MISSING;
12480         }
12481         return 0;
12482 }
12483
12484 /*
12485  * Only delete backref if REFERENCER_MISSING now
12486  *
12487  * Returns <0   the extent was deleted
12488  * Returns >0   the backref was deleted but extent still exists, returned value
12489  *               means error after repair
12490  * Returns  0   nothing happened
12491  */
12492 static int repair_extent_item(struct btrfs_trans_handle *trans,
12493                       struct btrfs_root *root, struct btrfs_path *path,
12494                       u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
12495                       u64 owner, u64 offset, int err)
12496 {
12497         struct btrfs_key old_key;
12498         int freed = 0;
12499         int ret;
12500
12501         btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]);
12502
12503         if (err & (REFERENCER_MISSING | REFERENCER_MISMATCH)) {
12504                 /* delete the backref */
12505                 ret = btrfs_free_extent(trans, root->fs_info->fs_root, bytenr,
12506                           num_bytes, parent, root_objectid, owner, offset);
12507                 if (!ret) {
12508                         freed = 1;
12509                         err &= ~REFERENCER_MISSING;
12510                         printf("Delete backref in extent [%llu %llu]\n",
12511                                bytenr, num_bytes);
12512                 } else {
12513                         error("fail to delete backref in extent [%llu %llu]",
12514                                bytenr, num_bytes);
12515                 }
12516         }
12517
12518         /* btrfs_free_extent may delete the extent */
12519         btrfs_release_path(path);
12520         ret = btrfs_search_slot(NULL, root, &old_key, path, 0, 0);
12521
12522         if (ret)
12523                 ret = -ENOENT;
12524         else if (freed)
12525                 ret = err;
12526         return ret;
12527 }
12528
12529 /*
12530  * This function will check a given extent item, including its backref and
12531  * itself (like crossing stripe boundary and type)
12532  *
12533  * Since we don't use extent_record anymore, introduce new error bit
12534  */
12535 static int check_extent_item(struct btrfs_trans_handle *trans,
12536                              struct btrfs_fs_info *fs_info,
12537                              struct btrfs_path *path)
12538 {
12539         struct btrfs_extent_item *ei;
12540         struct btrfs_extent_inline_ref *iref;
12541         struct btrfs_extent_data_ref *dref;
12542         struct extent_buffer *eb = path->nodes[0];
12543         unsigned long end;
12544         unsigned long ptr;
12545         int slot = path->slots[0];
12546         int type;
12547         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
12548         u32 item_size = btrfs_item_size_nr(eb, slot);
12549         u64 flags;
12550         u64 offset;
12551         u64 parent;
12552         u64 num_bytes;
12553         u64 root_objectid;
12554         u64 owner;
12555         u64 owner_offset;
12556         int metadata = 0;
12557         int level;
12558         struct btrfs_key key;
12559         int ret;
12560         int err = 0;
12561
12562         btrfs_item_key_to_cpu(eb, &key, slot);
12563         if (key.type == BTRFS_EXTENT_ITEM_KEY) {
12564                 bytes_used += key.offset;
12565                 num_bytes = key.offset;
12566         } else {
12567                 bytes_used += nodesize;
12568                 num_bytes = nodesize;
12569         }
12570
12571         if (item_size < sizeof(*ei)) {
12572                 /*
12573                  * COMPAT_EXTENT_TREE_V0 case, but it's already a super
12574                  * old thing when on disk format is still un-determined.
12575                  * No need to care about it anymore
12576                  */
12577                 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
12578                 return -ENOTTY;
12579         }
12580
12581         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
12582         flags = btrfs_extent_flags(eb, ei);
12583
12584         if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
12585                 metadata = 1;
12586         if (metadata && check_crossing_stripes(global_info, key.objectid,
12587                                                eb->len)) {
12588                 error("bad metadata [%llu, %llu) crossing stripe boundary",
12589                       key.objectid, key.objectid + nodesize);
12590                 err |= CROSSING_STRIPE_BOUNDARY;
12591         }
12592
12593         ptr = (unsigned long)(ei + 1);
12594
12595         if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
12596                 /* Old EXTENT_ITEM metadata */
12597                 struct btrfs_tree_block_info *info;
12598
12599                 info = (struct btrfs_tree_block_info *)ptr;
12600                 level = btrfs_tree_block_level(eb, info);
12601                 ptr += sizeof(struct btrfs_tree_block_info);
12602         } else {
12603                 /* New METADATA_ITEM */
12604                 level = key.offset;
12605         }
12606         end = (unsigned long)ei + item_size;
12607
12608 next:
12609         /* Reached extent item end normally */
12610         if (ptr == end)
12611                 goto out;
12612
12613         /* Beyond extent item end, wrong item size */
12614         if (ptr > end) {
12615                 err |= ITEM_SIZE_MISMATCH;
12616                 error("extent item at bytenr %llu slot %d has wrong size",
12617                         eb->start, slot);
12618                 goto out;
12619         }
12620
12621         parent = 0;
12622         root_objectid = 0;
12623         owner = 0;
12624         owner_offset = 0;
12625         /* Now check every backref in this extent item */
12626         iref = (struct btrfs_extent_inline_ref *)ptr;
12627         type = btrfs_extent_inline_ref_type(eb, iref);
12628         offset = btrfs_extent_inline_ref_offset(eb, iref);
12629         switch (type) {
12630         case BTRFS_TREE_BLOCK_REF_KEY:
12631                 root_objectid = offset;
12632                 owner = level;
12633                 ret = check_tree_block_backref(fs_info, offset, key.objectid,
12634                                                level);
12635                 err |= ret;
12636                 break;
12637         case BTRFS_SHARED_BLOCK_REF_KEY:
12638                 parent = offset;
12639                 ret = check_shared_block_backref(fs_info, offset, key.objectid,
12640                                                  level);
12641                 err |= ret;
12642                 break;
12643         case BTRFS_EXTENT_DATA_REF_KEY:
12644                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
12645                 root_objectid = btrfs_extent_data_ref_root(eb, dref);
12646                 owner = btrfs_extent_data_ref_objectid(eb, dref);
12647                 owner_offset = btrfs_extent_data_ref_offset(eb, dref);
12648                 ret = check_extent_data_backref(fs_info, root_objectid, owner,
12649                                         owner_offset, key.objectid, key.offset,
12650                                         btrfs_extent_data_ref_count(eb, dref));
12651                 err |= ret;
12652                 break;
12653         case BTRFS_SHARED_DATA_REF_KEY:
12654                 parent = offset;
12655                 ret = check_shared_data_backref(fs_info, offset, key.objectid);
12656                 err |= ret;
12657                 break;
12658         default:
12659                 error("extent[%llu %d %llu] has unknown ref type: %d",
12660                         key.objectid, key.type, key.offset, type);
12661                 ret = UNKNOWN_TYPE;
12662                 err |= ret;
12663                 goto out;
12664         }
12665
12666         if (err && repair) {
12667                 ret = repair_extent_item(trans, fs_info->extent_root, path,
12668                          key.objectid, num_bytes, parent, root_objectid,
12669                          owner, owner_offset, ret);
12670                 if (ret < 0)
12671                         goto out;
12672                 if (ret) {
12673                         goto next;
12674                         err = ret;
12675                 }
12676         }
12677
12678         ptr += btrfs_extent_inline_ref_size(type);
12679         goto next;
12680
12681 out:
12682         return err;
12683 }
12684
12685 /*
12686  * Check if a dev extent item is referred correctly by its chunk
12687  */
12688 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
12689                                  struct extent_buffer *eb, int slot)
12690 {
12691         struct btrfs_root *chunk_root = fs_info->chunk_root;
12692         struct btrfs_dev_extent *ptr;
12693         struct btrfs_path path;
12694         struct btrfs_key chunk_key;
12695         struct btrfs_key devext_key;
12696         struct btrfs_chunk *chunk;
12697         struct extent_buffer *l;
12698         int num_stripes;
12699         u64 length;
12700         int i;
12701         int found_chunk = 0;
12702         int ret;
12703
12704         btrfs_item_key_to_cpu(eb, &devext_key, slot);
12705         ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
12706         length = btrfs_dev_extent_length(eb, ptr);
12707
12708         chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
12709         chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
12710         chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
12711
12712         btrfs_init_path(&path);
12713         ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
12714         if (ret)
12715                 goto out;
12716
12717         l = path.nodes[0];
12718         chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
12719         ret = btrfs_check_chunk_valid(fs_info, l, chunk, path.slots[0],
12720                                       chunk_key.offset);
12721         if (ret < 0)
12722                 goto out;
12723
12724         if (btrfs_stripe_length(fs_info, l, chunk) != length)
12725                 goto out;
12726
12727         num_stripes = btrfs_chunk_num_stripes(l, chunk);
12728         for (i = 0; i < num_stripes; i++) {
12729                 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
12730                 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
12731
12732                 if (devid == devext_key.objectid &&
12733                     offset == devext_key.offset) {
12734                         found_chunk = 1;
12735                         break;
12736                 }
12737         }
12738 out:
12739         btrfs_release_path(&path);
12740         if (!found_chunk) {
12741                 error(
12742                 "device extent[%llu, %llu, %llu] did not find the related chunk",
12743                         devext_key.objectid, devext_key.offset, length);
12744                 return REFERENCER_MISSING;
12745         }
12746         return 0;
12747 }
12748
12749 /*
12750  * Check if the used space is correct with the dev item
12751  */
12752 static int check_dev_item(struct btrfs_fs_info *fs_info,
12753                           struct extent_buffer *eb, int slot)
12754 {
12755         struct btrfs_root *dev_root = fs_info->dev_root;
12756         struct btrfs_dev_item *dev_item;
12757         struct btrfs_path path;
12758         struct btrfs_key key;
12759         struct btrfs_dev_extent *ptr;
12760         u64 dev_id;
12761         u64 used;
12762         u64 total = 0;
12763         int ret;
12764
12765         dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
12766         dev_id = btrfs_device_id(eb, dev_item);
12767         used = btrfs_device_bytes_used(eb, dev_item);
12768
12769         key.objectid = dev_id;
12770         key.type = BTRFS_DEV_EXTENT_KEY;
12771         key.offset = 0;
12772
12773         btrfs_init_path(&path);
12774         ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
12775         if (ret < 0) {
12776                 btrfs_item_key_to_cpu(eb, &key, slot);
12777                 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
12778                         key.objectid, key.type, key.offset);
12779                 btrfs_release_path(&path);
12780                 return REFERENCER_MISSING;
12781         }
12782
12783         /* Iterate dev_extents to calculate the used space of a device */
12784         while (1) {
12785                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
12786                         goto next;
12787
12788                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12789                 if (key.objectid > dev_id)
12790                         break;
12791                 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
12792                         goto next;
12793
12794                 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
12795                                      struct btrfs_dev_extent);
12796                 total += btrfs_dev_extent_length(path.nodes[0], ptr);
12797 next:
12798                 ret = btrfs_next_item(dev_root, &path);
12799                 if (ret)
12800                         break;
12801         }
12802         btrfs_release_path(&path);
12803
12804         if (used != total) {
12805                 btrfs_item_key_to_cpu(eb, &key, slot);
12806                 error(
12807 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
12808                         total, used, BTRFS_ROOT_TREE_OBJECTID,
12809                         BTRFS_DEV_EXTENT_KEY, dev_id);
12810                 return ACCOUNTING_MISMATCH;
12811         }
12812         return 0;
12813 }
12814
12815 /*
12816  * Check a block group item with its referener (chunk) and its used space
12817  * with extent/metadata item
12818  */
12819 static int check_block_group_item(struct btrfs_fs_info *fs_info,
12820                                   struct extent_buffer *eb, int slot)
12821 {
12822         struct btrfs_root *extent_root = fs_info->extent_root;
12823         struct btrfs_root *chunk_root = fs_info->chunk_root;
12824         struct btrfs_block_group_item *bi;
12825         struct btrfs_block_group_item bg_item;
12826         struct btrfs_path path;
12827         struct btrfs_key bg_key;
12828         struct btrfs_key chunk_key;
12829         struct btrfs_key extent_key;
12830         struct btrfs_chunk *chunk;
12831         struct extent_buffer *leaf;
12832         struct btrfs_extent_item *ei;
12833         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
12834         u64 flags;
12835         u64 bg_flags;
12836         u64 used;
12837         u64 total = 0;
12838         int ret;
12839         int err = 0;
12840
12841         btrfs_item_key_to_cpu(eb, &bg_key, slot);
12842         bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
12843         read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
12844         used = btrfs_block_group_used(&bg_item);
12845         bg_flags = btrfs_block_group_flags(&bg_item);
12846
12847         chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
12848         chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
12849         chunk_key.offset = bg_key.objectid;
12850
12851         btrfs_init_path(&path);
12852         /* Search for the referencer chunk */
12853         ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
12854         if (ret) {
12855                 error(
12856                 "block group[%llu %llu] did not find the related chunk item",
12857                         bg_key.objectid, bg_key.offset);
12858                 err |= REFERENCER_MISSING;
12859         } else {
12860                 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
12861                                         struct btrfs_chunk);
12862                 if (btrfs_chunk_length(path.nodes[0], chunk) !=
12863                                                 bg_key.offset) {
12864                         error(
12865         "block group[%llu %llu] related chunk item length does not match",
12866                                 bg_key.objectid, bg_key.offset);
12867                         err |= REFERENCER_MISMATCH;
12868                 }
12869         }
12870         btrfs_release_path(&path);
12871
12872         /* Search from the block group bytenr */
12873         extent_key.objectid = bg_key.objectid;
12874         extent_key.type = 0;
12875         extent_key.offset = 0;
12876
12877         btrfs_init_path(&path);
12878         ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
12879         if (ret < 0)
12880                 goto out;
12881
12882         /* Iterate extent tree to account used space */
12883         while (1) {
12884                 leaf = path.nodes[0];
12885
12886                 /* Search slot can point to the last item beyond leaf nritems */
12887                 if (path.slots[0] >= btrfs_header_nritems(leaf))
12888                         goto next;
12889
12890                 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
12891                 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
12892                         break;
12893
12894                 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
12895                     extent_key.type != BTRFS_EXTENT_ITEM_KEY)
12896                         goto next;
12897                 if (extent_key.objectid < bg_key.objectid)
12898                         goto next;
12899
12900                 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
12901                         total += nodesize;
12902                 else
12903                         total += extent_key.offset;
12904
12905                 ei = btrfs_item_ptr(leaf, path.slots[0],
12906                                     struct btrfs_extent_item);
12907                 flags = btrfs_extent_flags(leaf, ei);
12908                 if (flags & BTRFS_EXTENT_FLAG_DATA) {
12909                         if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
12910                                 error(
12911                         "bad extent[%llu, %llu) type mismatch with chunk",
12912                                         extent_key.objectid,
12913                                         extent_key.objectid + extent_key.offset);
12914                                 err |= CHUNK_TYPE_MISMATCH;
12915                         }
12916                 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
12917                         if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
12918                                     BTRFS_BLOCK_GROUP_METADATA))) {
12919                                 error(
12920                         "bad extent[%llu, %llu) type mismatch with chunk",
12921                                         extent_key.objectid,
12922                                         extent_key.objectid + nodesize);
12923                                 err |= CHUNK_TYPE_MISMATCH;
12924                         }
12925                 }
12926 next:
12927                 ret = btrfs_next_item(extent_root, &path);
12928                 if (ret)
12929                         break;
12930         }
12931
12932 out:
12933         btrfs_release_path(&path);
12934
12935         if (total != used) {
12936                 error(
12937                 "block group[%llu %llu] used %llu but extent items used %llu",
12938                         bg_key.objectid, bg_key.offset, used, total);
12939                 err |= BG_ACCOUNTING_ERROR;
12940         }
12941         return err;
12942 }
12943
12944 /*
12945  * Add block group item to the extent tree if @err contains REFERENCER_MISSING.
12946  * FIXME: We still need to repair error of dev_item.
12947  *
12948  * Returns error after repair.
12949  */
12950 static int repair_chunk_item(struct btrfs_trans_handle *trans,
12951                              struct btrfs_root *chunk_root,
12952                              struct btrfs_path *path, int err)
12953 {
12954         struct btrfs_chunk *chunk;
12955         struct btrfs_key chunk_key;
12956         struct extent_buffer *eb = path->nodes[0];
12957         u64 length;
12958         int slot = path->slots[0];
12959         u64 type;
12960         int ret = 0;
12961
12962         btrfs_item_key_to_cpu(eb, &chunk_key, slot);
12963         if (chunk_key.type != BTRFS_CHUNK_ITEM_KEY)
12964                 return err;
12965         chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
12966         type = btrfs_chunk_type(path->nodes[0], chunk);
12967         length = btrfs_chunk_length(eb, chunk);
12968
12969         if (err & REFERENCER_MISSING) {
12970                 ret = btrfs_make_block_group(trans, chunk_root->fs_info, 0,
12971                      type, chunk_key.objectid, chunk_key.offset, length);
12972                 if (ret) {
12973                         error("fail to add block group item[%llu %llu]",
12974                               chunk_key.offset, length);
12975                         goto out;
12976                 } else {
12977                         err &= ~REFERENCER_MISSING;
12978                         printf("Added block group item[%llu %llu]\n",
12979                                chunk_key.offset, length);
12980                 }
12981         }
12982
12983 out:
12984         return err;
12985 }
12986
12987 /*
12988  * Check a chunk item.
12989  * Including checking all referred dev_extents and block group
12990  */
12991 static int check_chunk_item(struct btrfs_fs_info *fs_info,
12992                             struct extent_buffer *eb, int slot)
12993 {
12994         struct btrfs_root *extent_root = fs_info->extent_root;
12995         struct btrfs_root *dev_root = fs_info->dev_root;
12996         struct btrfs_path path;
12997         struct btrfs_key chunk_key;
12998         struct btrfs_key bg_key;
12999         struct btrfs_key devext_key;
13000         struct btrfs_chunk *chunk;
13001         struct extent_buffer *leaf;
13002         struct btrfs_block_group_item *bi;
13003         struct btrfs_block_group_item bg_item;
13004         struct btrfs_dev_extent *ptr;
13005         u64 length;
13006         u64 chunk_end;
13007         u64 stripe_len;
13008         u64 type;
13009         int num_stripes;
13010         u64 offset;
13011         u64 objectid;
13012         int i;
13013         int ret;
13014         int err = 0;
13015
13016         btrfs_item_key_to_cpu(eb, &chunk_key, slot);
13017         chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
13018         length = btrfs_chunk_length(eb, chunk);
13019         chunk_end = chunk_key.offset + length;
13020         ret = btrfs_check_chunk_valid(fs_info, eb, chunk, slot,
13021                                       chunk_key.offset);
13022         if (ret < 0) {
13023                 error("chunk[%llu %llu) is invalid", chunk_key.offset,
13024                         chunk_end);
13025                 err |= BYTES_UNALIGNED | UNKNOWN_TYPE;
13026                 goto out;
13027         }
13028         type = btrfs_chunk_type(eb, chunk);
13029
13030         bg_key.objectid = chunk_key.offset;
13031         bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
13032         bg_key.offset = length;
13033
13034         btrfs_init_path(&path);
13035         ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
13036         if (ret) {
13037                 error(
13038                 "chunk[%llu %llu) did not find the related block group item",
13039                         chunk_key.offset, chunk_end);
13040                 err |= REFERENCER_MISSING;
13041         } else{
13042                 leaf = path.nodes[0];
13043                 bi = btrfs_item_ptr(leaf, path.slots[0],
13044                                     struct btrfs_block_group_item);
13045                 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
13046                                    sizeof(bg_item));
13047                 if (btrfs_block_group_flags(&bg_item) != type) {
13048                         error(
13049 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
13050                                 chunk_key.offset, chunk_end, type,
13051                                 btrfs_block_group_flags(&bg_item));
13052                         err |= REFERENCER_MISSING;
13053                 }
13054         }
13055
13056         num_stripes = btrfs_chunk_num_stripes(eb, chunk);
13057         stripe_len = btrfs_stripe_length(fs_info, eb, chunk);
13058         for (i = 0; i < num_stripes; i++) {
13059                 btrfs_release_path(&path);
13060                 btrfs_init_path(&path);
13061                 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
13062                 devext_key.type = BTRFS_DEV_EXTENT_KEY;
13063                 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
13064
13065                 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
13066                                         0, 0);
13067                 if (ret)
13068                         goto not_match_dev;
13069
13070                 leaf = path.nodes[0];
13071                 ptr = btrfs_item_ptr(leaf, path.slots[0],
13072                                      struct btrfs_dev_extent);
13073                 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
13074                 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
13075                 if (objectid != chunk_key.objectid ||
13076                     offset != chunk_key.offset ||
13077                     btrfs_dev_extent_length(leaf, ptr) != stripe_len)
13078                         goto not_match_dev;
13079                 continue;
13080 not_match_dev:
13081                 err |= BACKREF_MISSING;
13082                 error(
13083                 "chunk[%llu %llu) stripe %d did not find the related dev extent",
13084                         chunk_key.objectid, chunk_end, i);
13085                 continue;
13086         }
13087         btrfs_release_path(&path);
13088 out:
13089         return err;
13090 }
13091
13092 static int delete_extent_tree_item(struct btrfs_trans_handle *trans,
13093                                    struct btrfs_root *root,
13094                                    struct btrfs_path *path)
13095 {
13096         struct btrfs_key key;
13097         int ret = 0;
13098
13099         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
13100         btrfs_release_path(path);
13101         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
13102         if (ret) {
13103                 ret = -ENOENT;
13104                 goto out;
13105         }
13106
13107         ret = btrfs_del_item(trans, root, path);
13108         if (ret)
13109                 goto out;
13110
13111         if (path->slots[0] == 0)
13112                 btrfs_prev_leaf(root, path);
13113         else
13114                 path->slots[0]--;
13115 out:
13116         if (ret)
13117                 error("failed to delete root %llu item[%llu, %u, %llu]",
13118                       root->objectid, key.objectid, key.type, key.offset);
13119         else
13120                 printf("Deleted root %llu item[%llu, %u, %llu]\n",
13121                        root->objectid, key.objectid, key.type, key.offset);
13122         return ret;
13123 }
13124
13125 /*
13126  * Main entry function to check known items and update related accounting info
13127  */
13128 static int check_leaf_items(struct btrfs_trans_handle *trans,
13129                             struct btrfs_root *root, struct btrfs_path *path,
13130                             struct node_refs *nrefs, int account_bytes)
13131 {
13132         struct btrfs_fs_info *fs_info = root->fs_info;
13133         struct btrfs_key key;
13134         struct extent_buffer *eb;
13135         int slot;
13136         int type;
13137         struct btrfs_extent_data_ref *dref;
13138         int ret = 0;
13139         int err = 0;
13140
13141 again:
13142         eb = path->nodes[0];
13143         slot = path->slots[0];
13144         if (slot >= btrfs_header_nritems(eb)) {
13145                 if (slot == 0) {
13146                         error("empty leaf [%llu %u] root %llu", eb->start,
13147                                 root->fs_info->nodesize, root->objectid);
13148                         err |= EIO;
13149                 }
13150                 goto out;
13151         }
13152
13153         btrfs_item_key_to_cpu(eb, &key, slot);
13154         type = key.type;
13155
13156         switch (type) {
13157         case BTRFS_EXTENT_DATA_KEY:
13158                 ret = check_extent_data_item(root, path, nrefs, account_bytes);
13159                 if (repair && ret)
13160                         ret = repair_extent_data_item(trans, root, path, nrefs,
13161                                                       ret);
13162                 err |= ret;
13163                 break;
13164         case BTRFS_BLOCK_GROUP_ITEM_KEY:
13165                 ret = check_block_group_item(fs_info, eb, slot);
13166                 if (repair &&
13167                     ret & REFERENCER_MISSING)
13168                         ret = delete_extent_tree_item(trans, root, path);
13169                 err |= ret;
13170                 break;
13171         case BTRFS_DEV_ITEM_KEY:
13172                 ret = check_dev_item(fs_info, eb, slot);
13173                 err |= ret;
13174                 break;
13175         case BTRFS_CHUNK_ITEM_KEY:
13176                 ret = check_chunk_item(fs_info, eb, slot);
13177                 if (repair && ret)
13178                         ret = repair_chunk_item(trans, root, path, ret);
13179                 err |= ret;
13180                 break;
13181         case BTRFS_DEV_EXTENT_KEY:
13182                 ret = check_dev_extent_item(fs_info, eb, slot);
13183                 err |= ret;
13184                 break;
13185         case BTRFS_EXTENT_ITEM_KEY:
13186         case BTRFS_METADATA_ITEM_KEY:
13187                 ret = check_extent_item(trans, fs_info, path);
13188                 err |= ret;
13189                 break;
13190         case BTRFS_EXTENT_CSUM_KEY:
13191                 total_csum_bytes += btrfs_item_size_nr(eb, slot);
13192                 err |= ret;
13193                 break;
13194         case BTRFS_TREE_BLOCK_REF_KEY:
13195                 ret = check_tree_block_backref(fs_info, key.offset,
13196                                                key.objectid, -1);
13197                 if (repair &&
13198                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
13199                         ret = delete_extent_tree_item(trans, root, path);
13200                 err |= ret;
13201                 break;
13202         case BTRFS_EXTENT_DATA_REF_KEY:
13203                 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
13204                 ret = check_extent_data_backref(fs_info,
13205                                 btrfs_extent_data_ref_root(eb, dref),
13206                                 btrfs_extent_data_ref_objectid(eb, dref),
13207                                 btrfs_extent_data_ref_offset(eb, dref),
13208                                 key.objectid, 0,
13209                                 btrfs_extent_data_ref_count(eb, dref));
13210                 if (repair &&
13211                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
13212                         ret = delete_extent_tree_item(trans, root, path);
13213                 err |= ret;
13214                 break;
13215         case BTRFS_SHARED_BLOCK_REF_KEY:
13216                 ret = check_shared_block_backref(fs_info, key.offset,
13217                                                  key.objectid, -1);
13218                 if (repair &&
13219                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
13220                         ret = delete_extent_tree_item(trans, root, path);
13221                 err |= ret;
13222                 break;
13223         case BTRFS_SHARED_DATA_REF_KEY:
13224                 ret = check_shared_data_backref(fs_info, key.offset,
13225                                                 key.objectid);
13226                 if (repair &&
13227                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
13228                         ret = delete_extent_tree_item(trans, root, path);
13229                 err |= ret;
13230                 break;
13231         default:
13232                 break;
13233         }
13234
13235         ++path->slots[0];
13236         goto again;
13237 out:
13238         return err;
13239 }
13240
13241 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info);
13242
13243 /*
13244  * Low memory usage version check_chunks_and_extents.
13245  */
13246 static int check_chunks_and_extents_v2(struct btrfs_fs_info *fs_info)
13247 {
13248         struct btrfs_trans_handle *trans = NULL;
13249         struct btrfs_path path;
13250         struct btrfs_key old_key;
13251         struct btrfs_key key;
13252         struct btrfs_root *root1;
13253         struct btrfs_root *root;
13254         struct btrfs_root *cur_root;
13255         int err = 0;
13256         int ret;
13257
13258         root = fs_info->fs_root;
13259
13260         if (repair) {
13261                 /* pin every tree block to avoid extent overwrite */
13262                 ret = pin_metadata_blocks(fs_info);
13263                 if (ret) {
13264                         error("failed to pin metadata blocks");
13265                         return ret;
13266                 }
13267                 trans = btrfs_start_transaction(fs_info->extent_root, 1);
13268                 if (IS_ERR(trans)) {
13269                         error("failed to start transaction before check");
13270                         return PTR_ERR(trans);
13271                 }
13272         }
13273
13274         root1 = root->fs_info->chunk_root;
13275         ret = check_btrfs_root(trans, root1, 0, 1);
13276         err |= ret;
13277
13278         root1 = root->fs_info->tree_root;
13279         ret = check_btrfs_root(trans, root1, 0, 1);
13280         err |= ret;
13281
13282         btrfs_init_path(&path);
13283         key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
13284         key.offset = 0;
13285         key.type = BTRFS_ROOT_ITEM_KEY;
13286
13287         ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
13288         if (ret) {
13289                 error("cannot find extent tree in tree_root");
13290                 goto out;
13291         }
13292
13293         while (1) {
13294                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
13295                 if (key.type != BTRFS_ROOT_ITEM_KEY)
13296                         goto next;
13297                 old_key = key;
13298                 key.offset = (u64)-1;
13299
13300                 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
13301                         cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
13302                                         &key);
13303                 else
13304                         cur_root = btrfs_read_fs_root(root->fs_info, &key);
13305                 if (IS_ERR(cur_root) || !cur_root) {
13306                         error("failed to read tree: %lld", key.objectid);
13307                         goto next;
13308                 }
13309
13310                 ret = check_btrfs_root(trans, cur_root, 0, 1);
13311                 err |= ret;
13312
13313                 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
13314                         btrfs_free_fs_root(cur_root);
13315
13316                 btrfs_release_path(&path);
13317                 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
13318                                         &old_key, &path, 0, 0);
13319                 if (ret)
13320                         goto out;
13321 next:
13322                 ret = btrfs_next_item(root1, &path);
13323                 if (ret)
13324                         goto out;
13325         }
13326 out:
13327
13328         /* if repair, update block accounting */
13329         if (repair) {
13330                 ret = btrfs_fix_block_accounting(trans, root);
13331                 if (ret)
13332                         err |= ret;
13333                 else
13334                         err &= ~BG_ACCOUNTING_ERROR;
13335         }
13336
13337         if (trans)
13338                 btrfs_commit_transaction(trans, root->fs_info->extent_root);
13339
13340         btrfs_release_path(&path);
13341
13342         return err;
13343 }
13344
13345 static int do_check_chunks_and_extents(struct btrfs_fs_info *fs_info)
13346 {
13347         int ret;
13348
13349         if (!ctx.progress_enabled)
13350                 fprintf(stderr, "checking extents\n");
13351         if (check_mode == CHECK_MODE_LOWMEM)
13352                 ret = check_chunks_and_extents_v2(fs_info);
13353         else
13354                 ret = check_chunks_and_extents(fs_info);
13355
13356         return ret;
13357 }
13358
13359 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
13360                            struct btrfs_root *root, int overwrite)
13361 {
13362         struct extent_buffer *c;
13363         struct extent_buffer *old = root->node;
13364         int level;
13365         int ret;
13366         struct btrfs_disk_key disk_key = {0,0,0};
13367
13368         level = 0;
13369
13370         if (overwrite) {
13371                 c = old;
13372                 extent_buffer_get(c);
13373                 goto init;
13374         }
13375         c = btrfs_alloc_free_block(trans, root,
13376                                    root->fs_info->nodesize,
13377                                    root->root_key.objectid,
13378                                    &disk_key, level, 0, 0);
13379         if (IS_ERR(c)) {
13380                 c = old;
13381                 extent_buffer_get(c);
13382                 overwrite = 1;
13383         }
13384 init:
13385         memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
13386         btrfs_set_header_level(c, level);
13387         btrfs_set_header_bytenr(c, c->start);
13388         btrfs_set_header_generation(c, trans->transid);
13389         btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
13390         btrfs_set_header_owner(c, root->root_key.objectid);
13391
13392         write_extent_buffer(c, root->fs_info->fsid,
13393                             btrfs_header_fsid(), BTRFS_FSID_SIZE);
13394
13395         write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
13396                             btrfs_header_chunk_tree_uuid(c),
13397                             BTRFS_UUID_SIZE);
13398
13399         btrfs_mark_buffer_dirty(c);
13400         /*
13401          * this case can happen in the following case:
13402          *
13403          * 1.overwrite previous root.
13404          *
13405          * 2.reinit reloc data root, this is because we skip pin
13406          * down reloc data tree before which means we can allocate
13407          * same block bytenr here.
13408          */
13409         if (old->start == c->start) {
13410                 btrfs_set_root_generation(&root->root_item,
13411                                           trans->transid);
13412                 root->root_item.level = btrfs_header_level(root->node);
13413                 ret = btrfs_update_root(trans, root->fs_info->tree_root,
13414                                         &root->root_key, &root->root_item);
13415                 if (ret) {
13416                         free_extent_buffer(c);
13417                         return ret;
13418                 }
13419         }
13420         free_extent_buffer(old);
13421         root->node = c;
13422         add_root_to_dirty_list(root);
13423         return 0;
13424 }
13425
13426 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
13427                                 struct extent_buffer *eb, int tree_root)
13428 {
13429         struct extent_buffer *tmp;
13430         struct btrfs_root_item *ri;
13431         struct btrfs_key key;
13432         u64 bytenr;
13433         int level = btrfs_header_level(eb);
13434         int nritems;
13435         int ret;
13436         int i;
13437
13438         /*
13439          * If we have pinned this block before, don't pin it again.
13440          * This can not only avoid forever loop with broken filesystem
13441          * but also give us some speedups.
13442          */
13443         if (test_range_bit(&fs_info->pinned_extents, eb->start,
13444                            eb->start + eb->len - 1, EXTENT_DIRTY, 0))
13445                 return 0;
13446
13447         btrfs_pin_extent(fs_info, eb->start, eb->len);
13448
13449         nritems = btrfs_header_nritems(eb);
13450         for (i = 0; i < nritems; i++) {
13451                 if (level == 0) {
13452                         btrfs_item_key_to_cpu(eb, &key, i);
13453                         if (key.type != BTRFS_ROOT_ITEM_KEY)
13454                                 continue;
13455                         /* Skip the extent root and reloc roots */
13456                         if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
13457                             key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
13458                             key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
13459                                 continue;
13460                         ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
13461                         bytenr = btrfs_disk_root_bytenr(eb, ri);
13462
13463                         /*
13464                          * If at any point we start needing the real root we
13465                          * will have to build a stump root for the root we are
13466                          * in, but for now this doesn't actually use the root so
13467                          * just pass in extent_root.
13468                          */
13469                         tmp = read_tree_block(fs_info, bytenr, 0);
13470                         if (!extent_buffer_uptodate(tmp)) {
13471                                 fprintf(stderr, "Error reading root block\n");
13472                                 return -EIO;
13473                         }
13474                         ret = pin_down_tree_blocks(fs_info, tmp, 0);
13475                         free_extent_buffer(tmp);
13476                         if (ret)
13477                                 return ret;
13478                 } else {
13479                         bytenr = btrfs_node_blockptr(eb, i);
13480
13481                         /* If we aren't the tree root don't read the block */
13482                         if (level == 1 && !tree_root) {
13483                                 btrfs_pin_extent(fs_info, bytenr,
13484                                                 fs_info->nodesize);
13485                                 continue;
13486                         }
13487
13488                         tmp = read_tree_block(fs_info, bytenr, 0);
13489                         if (!extent_buffer_uptodate(tmp)) {
13490                                 fprintf(stderr, "Error reading tree block\n");
13491                                 return -EIO;
13492                         }
13493                         ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
13494                         free_extent_buffer(tmp);
13495                         if (ret)
13496                                 return ret;
13497                 }
13498         }
13499
13500         return 0;
13501 }
13502
13503 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
13504 {
13505         int ret;
13506
13507         ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
13508         if (ret)
13509                 return ret;
13510
13511         return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
13512 }
13513
13514 static int reset_block_groups(struct btrfs_fs_info *fs_info)
13515 {
13516         struct btrfs_block_group_cache *cache;
13517         struct btrfs_path path;
13518         struct extent_buffer *leaf;
13519         struct btrfs_chunk *chunk;
13520         struct btrfs_key key;
13521         int ret;
13522         u64 start;
13523
13524         btrfs_init_path(&path);
13525         key.objectid = 0;
13526         key.type = BTRFS_CHUNK_ITEM_KEY;
13527         key.offset = 0;
13528         ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
13529         if (ret < 0) {
13530                 btrfs_release_path(&path);
13531                 return ret;
13532         }
13533
13534         /*
13535          * We do this in case the block groups were screwed up and had alloc
13536          * bits that aren't actually set on the chunks.  This happens with
13537          * restored images every time and could happen in real life I guess.
13538          */
13539         fs_info->avail_data_alloc_bits = 0;
13540         fs_info->avail_metadata_alloc_bits = 0;
13541         fs_info->avail_system_alloc_bits = 0;
13542
13543         /* First we need to create the in-memory block groups */
13544         while (1) {
13545                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
13546                         ret = btrfs_next_leaf(fs_info->chunk_root, &path);
13547                         if (ret < 0) {
13548                                 btrfs_release_path(&path);
13549                                 return ret;
13550                         }
13551                         if (ret) {
13552                                 ret = 0;
13553                                 break;
13554                         }
13555                 }
13556                 leaf = path.nodes[0];
13557                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
13558                 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
13559                         path.slots[0]++;
13560                         continue;
13561                 }
13562
13563                 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
13564                 btrfs_add_block_group(fs_info, 0,
13565                                       btrfs_chunk_type(leaf, chunk),
13566                                       key.objectid, key.offset,
13567                                       btrfs_chunk_length(leaf, chunk));
13568                 set_extent_dirty(&fs_info->free_space_cache, key.offset,
13569                                  key.offset + btrfs_chunk_length(leaf, chunk));
13570                 path.slots[0]++;
13571         }
13572         start = 0;
13573         while (1) {
13574                 cache = btrfs_lookup_first_block_group(fs_info, start);
13575                 if (!cache)
13576                         break;
13577                 cache->cached = 1;
13578                 start = cache->key.objectid + cache->key.offset;
13579         }
13580
13581         btrfs_release_path(&path);
13582         return 0;
13583 }
13584
13585 static int reset_balance(struct btrfs_trans_handle *trans,
13586                          struct btrfs_fs_info *fs_info)
13587 {
13588         struct btrfs_root *root = fs_info->tree_root;
13589         struct btrfs_path path;
13590         struct extent_buffer *leaf;
13591         struct btrfs_key key;
13592         int del_slot, del_nr = 0;
13593         int ret;
13594         int found = 0;
13595
13596         btrfs_init_path(&path);
13597         key.objectid = BTRFS_BALANCE_OBJECTID;
13598         key.type = BTRFS_BALANCE_ITEM_KEY;
13599         key.offset = 0;
13600         ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
13601         if (ret) {
13602                 if (ret > 0)
13603                         ret = 0;
13604                 if (!ret)
13605                         goto reinit_data_reloc;
13606                 else
13607                         goto out;
13608         }
13609
13610         ret = btrfs_del_item(trans, root, &path);
13611         if (ret)
13612                 goto out;
13613         btrfs_release_path(&path);
13614
13615         key.objectid = BTRFS_TREE_RELOC_OBJECTID;
13616         key.type = BTRFS_ROOT_ITEM_KEY;
13617         key.offset = 0;
13618         ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
13619         if (ret < 0)
13620                 goto out;
13621         while (1) {
13622                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
13623                         if (!found)
13624                                 break;
13625
13626                         if (del_nr) {
13627                                 ret = btrfs_del_items(trans, root, &path,
13628                                                       del_slot, del_nr);
13629                                 del_nr = 0;
13630                                 if (ret)
13631                                         goto out;
13632                         }
13633                         key.offset++;
13634                         btrfs_release_path(&path);
13635
13636                         found = 0;
13637                         ret = btrfs_search_slot(trans, root, &key, &path,
13638                                                 -1, 1);
13639                         if (ret < 0)
13640                                 goto out;
13641                         continue;
13642                 }
13643                 found = 1;
13644                 leaf = path.nodes[0];
13645                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
13646                 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
13647                         break;
13648                 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
13649                         path.slots[0]++;
13650                         continue;
13651                 }
13652                 if (!del_nr) {
13653                         del_slot = path.slots[0];
13654                         del_nr = 1;
13655                 } else {
13656                         del_nr++;
13657                 }
13658                 path.slots[0]++;
13659         }
13660
13661         if (del_nr) {
13662                 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
13663                 if (ret)
13664                         goto out;
13665         }
13666         btrfs_release_path(&path);
13667
13668 reinit_data_reloc:
13669         key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
13670         key.type = BTRFS_ROOT_ITEM_KEY;
13671         key.offset = (u64)-1;
13672         root = btrfs_read_fs_root(fs_info, &key);
13673         if (IS_ERR(root)) {
13674                 fprintf(stderr, "Error reading data reloc tree\n");
13675                 ret = PTR_ERR(root);
13676                 goto out;
13677         }
13678         record_root_in_trans(trans, root);
13679         ret = btrfs_fsck_reinit_root(trans, root, 0);
13680         if (ret)
13681                 goto out;
13682         ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
13683 out:
13684         btrfs_release_path(&path);
13685         return ret;
13686 }
13687
13688 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
13689                               struct btrfs_fs_info *fs_info)
13690 {
13691         u64 start = 0;
13692         int ret;
13693
13694         /*
13695          * The only reason we don't do this is because right now we're just
13696          * walking the trees we find and pinning down their bytes, we don't look
13697          * at any of the leaves.  In order to do mixed groups we'd have to check
13698          * the leaves of any fs roots and pin down the bytes for any file
13699          * extents we find.  Not hard but why do it if we don't have to?
13700          */
13701         if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
13702                 fprintf(stderr, "We don't support re-initing the extent tree "
13703                         "for mixed block groups yet, please notify a btrfs "
13704                         "developer you want to do this so they can add this "
13705                         "functionality.\n");
13706                 return -EINVAL;
13707         }
13708
13709         /*
13710          * first we need to walk all of the trees except the extent tree and pin
13711          * down the bytes that are in use so we don't overwrite any existing
13712          * metadata.
13713          */
13714         ret = pin_metadata_blocks(fs_info);
13715         if (ret) {
13716                 fprintf(stderr, "error pinning down used bytes\n");
13717                 return ret;
13718         }
13719
13720         /*
13721          * Need to drop all the block groups since we're going to recreate all
13722          * of them again.
13723          */
13724         btrfs_free_block_groups(fs_info);
13725         ret = reset_block_groups(fs_info);
13726         if (ret) {
13727                 fprintf(stderr, "error resetting the block groups\n");
13728                 return ret;
13729         }
13730
13731         /* Ok we can allocate now, reinit the extent root */
13732         ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
13733         if (ret) {
13734                 fprintf(stderr, "extent root initialization failed\n");
13735                 /*
13736                  * When the transaction code is updated we should end the
13737                  * transaction, but for now progs only knows about commit so
13738                  * just return an error.
13739                  */
13740                 return ret;
13741         }
13742
13743         /*
13744          * Now we have all the in-memory block groups setup so we can make
13745          * allocations properly, and the metadata we care about is safe since we
13746          * pinned all of it above.
13747          */
13748         while (1) {
13749                 struct btrfs_block_group_cache *cache;
13750
13751                 cache = btrfs_lookup_first_block_group(fs_info, start);
13752                 if (!cache)
13753                         break;
13754                 start = cache->key.objectid + cache->key.offset;
13755                 ret = btrfs_insert_item(trans, fs_info->extent_root,
13756                                         &cache->key, &cache->item,
13757                                         sizeof(cache->item));
13758                 if (ret) {
13759                         fprintf(stderr, "Error adding block group\n");
13760                         return ret;
13761                 }
13762                 btrfs_extent_post_op(trans, fs_info->extent_root);
13763         }
13764
13765         ret = reset_balance(trans, fs_info);
13766         if (ret)
13767                 fprintf(stderr, "error resetting the pending balance\n");
13768
13769         return ret;
13770 }
13771
13772 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
13773 {
13774         struct btrfs_path path;
13775         struct btrfs_trans_handle *trans;
13776         struct btrfs_key key;
13777         int ret;
13778
13779         printf("Recowing metadata block %llu\n", eb->start);
13780         key.objectid = btrfs_header_owner(eb);
13781         key.type = BTRFS_ROOT_ITEM_KEY;
13782         key.offset = (u64)-1;
13783
13784         root = btrfs_read_fs_root(root->fs_info, &key);
13785         if (IS_ERR(root)) {
13786                 fprintf(stderr, "Couldn't find owner root %llu\n",
13787                         key.objectid);
13788                 return PTR_ERR(root);
13789         }
13790
13791         trans = btrfs_start_transaction(root, 1);
13792         if (IS_ERR(trans))
13793                 return PTR_ERR(trans);
13794
13795         btrfs_init_path(&path);
13796         path.lowest_level = btrfs_header_level(eb);
13797         if (path.lowest_level)
13798                 btrfs_node_key_to_cpu(eb, &key, 0);
13799         else
13800                 btrfs_item_key_to_cpu(eb, &key, 0);
13801
13802         ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
13803         btrfs_commit_transaction(trans, root);
13804         btrfs_release_path(&path);
13805         return ret;
13806 }
13807
13808 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
13809 {
13810         struct btrfs_path path;
13811         struct btrfs_trans_handle *trans;
13812         struct btrfs_key key;
13813         int ret;
13814
13815         printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
13816                bad->key.type, bad->key.offset);
13817         key.objectid = bad->root_id;
13818         key.type = BTRFS_ROOT_ITEM_KEY;
13819         key.offset = (u64)-1;
13820
13821         root = btrfs_read_fs_root(root->fs_info, &key);
13822         if (IS_ERR(root)) {
13823                 fprintf(stderr, "Couldn't find owner root %llu\n",
13824                         key.objectid);
13825                 return PTR_ERR(root);
13826         }
13827
13828         trans = btrfs_start_transaction(root, 1);
13829         if (IS_ERR(trans))
13830                 return PTR_ERR(trans);
13831
13832         btrfs_init_path(&path);
13833         ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
13834         if (ret) {
13835                 if (ret > 0)
13836                         ret = 0;
13837                 goto out;
13838         }
13839         ret = btrfs_del_item(trans, root, &path);
13840 out:
13841         btrfs_commit_transaction(trans, root);
13842         btrfs_release_path(&path);
13843         return ret;
13844 }
13845
13846 static int zero_log_tree(struct btrfs_root *root)
13847 {
13848         struct btrfs_trans_handle *trans;
13849         int ret;
13850
13851         trans = btrfs_start_transaction(root, 1);
13852         if (IS_ERR(trans)) {
13853                 ret = PTR_ERR(trans);
13854                 return ret;
13855         }
13856         btrfs_set_super_log_root(root->fs_info->super_copy, 0);
13857         btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
13858         ret = btrfs_commit_transaction(trans, root);
13859         return ret;
13860 }
13861
13862 static int populate_csum(struct btrfs_trans_handle *trans,
13863                          struct btrfs_root *csum_root, char *buf, u64 start,
13864                          u64 len)
13865 {
13866         struct btrfs_fs_info *fs_info = csum_root->fs_info;
13867         u64 offset = 0;
13868         u64 sectorsize;
13869         int ret = 0;
13870
13871         while (offset < len) {
13872                 sectorsize = fs_info->sectorsize;
13873                 ret = read_extent_data(fs_info, buf, start + offset,
13874                                        &sectorsize, 0);
13875                 if (ret)
13876                         break;
13877                 ret = btrfs_csum_file_block(trans, csum_root, start + len,
13878                                             start + offset, buf, sectorsize);
13879                 if (ret)
13880                         break;
13881                 offset += sectorsize;
13882         }
13883         return ret;
13884 }
13885
13886 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
13887                                       struct btrfs_root *csum_root,
13888                                       struct btrfs_root *cur_root)
13889 {
13890         struct btrfs_path path;
13891         struct btrfs_key key;
13892         struct extent_buffer *node;
13893         struct btrfs_file_extent_item *fi;
13894         char *buf = NULL;
13895         u64 start = 0;
13896         u64 len = 0;
13897         int slot = 0;
13898         int ret = 0;
13899
13900         buf = malloc(cur_root->fs_info->sectorsize);
13901         if (!buf)
13902                 return -ENOMEM;
13903
13904         btrfs_init_path(&path);
13905         key.objectid = 0;
13906         key.offset = 0;
13907         key.type = 0;
13908         ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
13909         if (ret < 0)
13910                 goto out;
13911         /* Iterate all regular file extents and fill its csum */
13912         while (1) {
13913                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
13914
13915                 if (key.type != BTRFS_EXTENT_DATA_KEY)
13916                         goto next;
13917                 node = path.nodes[0];
13918                 slot = path.slots[0];
13919                 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
13920                 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
13921                         goto next;
13922                 start = btrfs_file_extent_disk_bytenr(node, fi);
13923                 len = btrfs_file_extent_disk_num_bytes(node, fi);
13924
13925                 ret = populate_csum(trans, csum_root, buf, start, len);
13926                 if (ret == -EEXIST)
13927                         ret = 0;
13928                 if (ret < 0)
13929                         goto out;
13930 next:
13931                 /*
13932                  * TODO: if next leaf is corrupted, jump to nearest next valid
13933                  * leaf.
13934                  */
13935                 ret = btrfs_next_item(cur_root, &path);
13936                 if (ret < 0)
13937                         goto out;
13938                 if (ret > 0) {
13939                         ret = 0;
13940                         goto out;
13941                 }
13942         }
13943
13944 out:
13945         btrfs_release_path(&path);
13946         free(buf);
13947         return ret;
13948 }
13949
13950 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
13951                                   struct btrfs_root *csum_root)
13952 {
13953         struct btrfs_fs_info *fs_info = csum_root->fs_info;
13954         struct btrfs_path path;
13955         struct btrfs_root *tree_root = fs_info->tree_root;
13956         struct btrfs_root *cur_root;
13957         struct extent_buffer *node;
13958         struct btrfs_key key;
13959         int slot = 0;
13960         int ret = 0;
13961
13962         btrfs_init_path(&path);
13963         key.objectid = BTRFS_FS_TREE_OBJECTID;
13964         key.offset = 0;
13965         key.type = BTRFS_ROOT_ITEM_KEY;
13966         ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
13967         if (ret < 0)
13968                 goto out;
13969         if (ret > 0) {
13970                 ret = -ENOENT;
13971                 goto out;
13972         }
13973
13974         while (1) {
13975                 node = path.nodes[0];
13976                 slot = path.slots[0];
13977                 btrfs_item_key_to_cpu(node, &key, slot);
13978                 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
13979                         goto out;
13980                 if (key.type != BTRFS_ROOT_ITEM_KEY)
13981                         goto next;
13982                 if (!is_fstree(key.objectid))
13983                         goto next;
13984                 key.offset = (u64)-1;
13985
13986                 cur_root = btrfs_read_fs_root(fs_info, &key);
13987                 if (IS_ERR(cur_root) || !cur_root) {
13988                         fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
13989                                 key.objectid);
13990                         goto out;
13991                 }
13992                 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
13993                                 cur_root);
13994                 if (ret < 0)
13995                         goto out;
13996 next:
13997                 ret = btrfs_next_item(tree_root, &path);
13998                 if (ret > 0) {
13999                         ret = 0;
14000                         goto out;
14001                 }
14002                 if (ret < 0)
14003                         goto out;
14004         }
14005
14006 out:
14007         btrfs_release_path(&path);
14008         return ret;
14009 }
14010
14011 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
14012                                       struct btrfs_root *csum_root)
14013 {
14014         struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
14015         struct btrfs_path path;
14016         struct btrfs_extent_item *ei;
14017         struct extent_buffer *leaf;
14018         char *buf;
14019         struct btrfs_key key;
14020         int ret;
14021
14022         btrfs_init_path(&path);
14023         key.objectid = 0;
14024         key.type = BTRFS_EXTENT_ITEM_KEY;
14025         key.offset = 0;
14026         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
14027         if (ret < 0) {
14028                 btrfs_release_path(&path);
14029                 return ret;
14030         }
14031
14032         buf = malloc(csum_root->fs_info->sectorsize);
14033         if (!buf) {
14034                 btrfs_release_path(&path);
14035                 return -ENOMEM;
14036         }
14037
14038         while (1) {
14039                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
14040                         ret = btrfs_next_leaf(extent_root, &path);
14041                         if (ret < 0)
14042                                 break;
14043                         if (ret) {
14044                                 ret = 0;
14045                                 break;
14046                         }
14047                 }
14048                 leaf = path.nodes[0];
14049
14050                 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
14051                 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
14052                         path.slots[0]++;
14053                         continue;
14054                 }
14055
14056                 ei = btrfs_item_ptr(leaf, path.slots[0],
14057                                     struct btrfs_extent_item);
14058                 if (!(btrfs_extent_flags(leaf, ei) &
14059                       BTRFS_EXTENT_FLAG_DATA)) {
14060                         path.slots[0]++;
14061                         continue;
14062                 }
14063
14064                 ret = populate_csum(trans, csum_root, buf, key.objectid,
14065                                     key.offset);
14066                 if (ret)
14067                         break;
14068                 path.slots[0]++;
14069         }
14070
14071         btrfs_release_path(&path);
14072         free(buf);
14073         return ret;
14074 }
14075
14076 /*
14077  * Recalculate the csum and put it into the csum tree.
14078  *
14079  * Extent tree init will wipe out all the extent info, so in that case, we
14080  * can't depend on extent tree, but use fs tree.  If search_fs_tree is set, we
14081  * will use fs/subvol trees to init the csum tree.
14082  */
14083 static int fill_csum_tree(struct btrfs_trans_handle *trans,
14084                           struct btrfs_root *csum_root,
14085                           int search_fs_tree)
14086 {
14087         if (search_fs_tree)
14088                 return fill_csum_tree_from_fs(trans, csum_root);
14089         else
14090                 return fill_csum_tree_from_extent(trans, csum_root);
14091 }
14092
14093 static void free_roots_info_cache(void)
14094 {
14095         if (!roots_info_cache)
14096                 return;
14097
14098         while (!cache_tree_empty(roots_info_cache)) {
14099                 struct cache_extent *entry;
14100                 struct root_item_info *rii;
14101
14102                 entry = first_cache_extent(roots_info_cache);
14103                 if (!entry)
14104                         break;
14105                 remove_cache_extent(roots_info_cache, entry);
14106                 rii = container_of(entry, struct root_item_info, cache_extent);
14107                 free(rii);
14108         }
14109
14110         free(roots_info_cache);
14111         roots_info_cache = NULL;
14112 }
14113
14114 static int build_roots_info_cache(struct btrfs_fs_info *info)
14115 {
14116         int ret = 0;
14117         struct btrfs_key key;
14118         struct extent_buffer *leaf;
14119         struct btrfs_path path;
14120
14121         if (!roots_info_cache) {
14122                 roots_info_cache = malloc(sizeof(*roots_info_cache));
14123                 if (!roots_info_cache)
14124                         return -ENOMEM;
14125                 cache_tree_init(roots_info_cache);
14126         }
14127
14128         btrfs_init_path(&path);
14129         key.objectid = 0;
14130         key.type = BTRFS_EXTENT_ITEM_KEY;
14131         key.offset = 0;
14132         ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
14133         if (ret < 0)
14134                 goto out;
14135         leaf = path.nodes[0];
14136
14137         while (1) {
14138                 struct btrfs_key found_key;
14139                 struct btrfs_extent_item *ei;
14140                 struct btrfs_extent_inline_ref *iref;
14141                 int slot = path.slots[0];
14142                 int type;
14143                 u64 flags;
14144                 u64 root_id;
14145                 u8 level;
14146                 struct cache_extent *entry;
14147                 struct root_item_info *rii;
14148
14149                 if (slot >= btrfs_header_nritems(leaf)) {
14150                         ret = btrfs_next_leaf(info->extent_root, &path);
14151                         if (ret < 0) {
14152                                 break;
14153                         } else if (ret) {
14154                                 ret = 0;
14155                                 break;
14156                         }
14157                         leaf = path.nodes[0];
14158                         slot = path.slots[0];
14159                 }
14160
14161                 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
14162
14163                 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
14164                     found_key.type != BTRFS_METADATA_ITEM_KEY)
14165                         goto next;
14166
14167                 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
14168                 flags = btrfs_extent_flags(leaf, ei);
14169
14170                 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
14171                     !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
14172                         goto next;
14173
14174                 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
14175                         iref = (struct btrfs_extent_inline_ref *)(ei + 1);
14176                         level = found_key.offset;
14177                 } else {
14178                         struct btrfs_tree_block_info *binfo;
14179
14180                         binfo = (struct btrfs_tree_block_info *)(ei + 1);
14181                         iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
14182                         level = btrfs_tree_block_level(leaf, binfo);
14183                 }
14184
14185                 /*
14186                  * For a root extent, it must be of the following type and the
14187                  * first (and only one) iref in the item.
14188                  */
14189                 type = btrfs_extent_inline_ref_type(leaf, iref);
14190                 if (type != BTRFS_TREE_BLOCK_REF_KEY)
14191                         goto next;
14192
14193                 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
14194                 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
14195                 if (!entry) {
14196                         rii = malloc(sizeof(struct root_item_info));
14197                         if (!rii) {
14198                                 ret = -ENOMEM;
14199                                 goto out;
14200                         }
14201                         rii->cache_extent.start = root_id;
14202                         rii->cache_extent.size = 1;
14203                         rii->level = (u8)-1;
14204                         entry = &rii->cache_extent;
14205                         ret = insert_cache_extent(roots_info_cache, entry);
14206                         ASSERT(ret == 0);
14207                 } else {
14208                         rii = container_of(entry, struct root_item_info,
14209                                            cache_extent);
14210                 }
14211
14212                 ASSERT(rii->cache_extent.start == root_id);
14213                 ASSERT(rii->cache_extent.size == 1);
14214
14215                 if (level > rii->level || rii->level == (u8)-1) {
14216                         rii->level = level;
14217                         rii->bytenr = found_key.objectid;
14218                         rii->gen = btrfs_extent_generation(leaf, ei);
14219                         rii->node_count = 1;
14220                 } else if (level == rii->level) {
14221                         rii->node_count++;
14222                 }
14223 next:
14224                 path.slots[0]++;
14225         }
14226
14227 out:
14228         btrfs_release_path(&path);
14229
14230         return ret;
14231 }
14232
14233 static int maybe_repair_root_item(struct btrfs_path *path,
14234                                   const struct btrfs_key *root_key,
14235                                   const int read_only_mode)
14236 {
14237         const u64 root_id = root_key->objectid;
14238         struct cache_extent *entry;
14239         struct root_item_info *rii;
14240         struct btrfs_root_item ri;
14241         unsigned long offset;
14242
14243         entry = lookup_cache_extent(roots_info_cache, root_id, 1);
14244         if (!entry) {
14245                 fprintf(stderr,
14246                         "Error: could not find extent items for root %llu\n",
14247                         root_key->objectid);
14248                 return -ENOENT;
14249         }
14250
14251         rii = container_of(entry, struct root_item_info, cache_extent);
14252         ASSERT(rii->cache_extent.start == root_id);
14253         ASSERT(rii->cache_extent.size == 1);
14254
14255         if (rii->node_count != 1) {
14256                 fprintf(stderr,
14257                         "Error: could not find btree root extent for root %llu\n",
14258                         root_id);
14259                 return -ENOENT;
14260         }
14261
14262         offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
14263         read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
14264
14265         if (btrfs_root_bytenr(&ri) != rii->bytenr ||
14266             btrfs_root_level(&ri) != rii->level ||
14267             btrfs_root_generation(&ri) != rii->gen) {
14268
14269                 /*
14270                  * If we're in repair mode but our caller told us to not update
14271                  * the root item, i.e. just check if it needs to be updated, don't
14272                  * print this message, since the caller will call us again shortly
14273                  * for the same root item without read only mode (the caller will
14274                  * open a transaction first).
14275                  */
14276                 if (!(read_only_mode && repair))
14277                         fprintf(stderr,
14278                                 "%sroot item for root %llu,"
14279                                 " current bytenr %llu, current gen %llu, current level %u,"
14280                                 " new bytenr %llu, new gen %llu, new level %u\n",
14281                                 (read_only_mode ? "" : "fixing "),
14282                                 root_id,
14283                                 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
14284                                 btrfs_root_level(&ri),
14285                                 rii->bytenr, rii->gen, rii->level);
14286
14287                 if (btrfs_root_generation(&ri) > rii->gen) {
14288                         fprintf(stderr,
14289                                 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
14290                                 root_id, btrfs_root_generation(&ri), rii->gen);
14291                         return -EINVAL;
14292                 }
14293
14294                 if (!read_only_mode) {
14295                         btrfs_set_root_bytenr(&ri, rii->bytenr);
14296                         btrfs_set_root_level(&ri, rii->level);
14297                         btrfs_set_root_generation(&ri, rii->gen);
14298                         write_extent_buffer(path->nodes[0], &ri,
14299                                             offset, sizeof(ri));
14300                 }
14301
14302                 return 1;
14303         }
14304
14305         return 0;
14306 }
14307
14308 /*
14309  * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
14310  * caused read-only snapshots to be corrupted if they were created at a moment
14311  * when the source subvolume/snapshot had orphan items. The issue was that the
14312  * on-disk root items became incorrect, referring to the pre orphan cleanup root
14313  * node instead of the post orphan cleanup root node.
14314  * So this function, and its callees, just detects and fixes those cases. Even
14315  * though the regression was for read-only snapshots, this function applies to
14316  * any snapshot/subvolume root.
14317  * This must be run before any other repair code - not doing it so, makes other
14318  * repair code delete or modify backrefs in the extent tree for example, which
14319  * will result in an inconsistent fs after repairing the root items.
14320  */
14321 static int repair_root_items(struct btrfs_fs_info *info)
14322 {
14323         struct btrfs_path path;
14324         struct btrfs_key key;
14325         struct extent_buffer *leaf;
14326         struct btrfs_trans_handle *trans = NULL;
14327         int ret = 0;
14328         int bad_roots = 0;
14329         int need_trans = 0;
14330
14331         btrfs_init_path(&path);
14332
14333         ret = build_roots_info_cache(info);
14334         if (ret)
14335                 goto out;
14336
14337         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
14338         key.type = BTRFS_ROOT_ITEM_KEY;
14339         key.offset = 0;
14340
14341 again:
14342         /*
14343          * Avoid opening and committing transactions if a leaf doesn't have
14344          * any root items that need to be fixed, so that we avoid rotating
14345          * backup roots unnecessarily.
14346          */
14347         if (need_trans) {
14348                 trans = btrfs_start_transaction(info->tree_root, 1);
14349                 if (IS_ERR(trans)) {
14350                         ret = PTR_ERR(trans);
14351                         goto out;
14352                 }
14353         }
14354
14355         ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
14356                                 0, trans ? 1 : 0);
14357         if (ret < 0)
14358                 goto out;
14359         leaf = path.nodes[0];
14360
14361         while (1) {
14362                 struct btrfs_key found_key;
14363
14364                 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
14365                         int no_more_keys = find_next_key(&path, &key);
14366
14367                         btrfs_release_path(&path);
14368                         if (trans) {
14369                                 ret = btrfs_commit_transaction(trans,
14370                                                                info->tree_root);
14371                                 trans = NULL;
14372                                 if (ret < 0)
14373                                         goto out;
14374                         }
14375                         need_trans = 0;
14376                         if (no_more_keys)
14377                                 break;
14378                         goto again;
14379                 }
14380
14381                 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
14382
14383                 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
14384                         goto next;
14385                 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
14386                         goto next;
14387
14388                 ret = maybe_repair_root_item(&path, &found_key, trans ? 0 : 1);
14389                 if (ret < 0)
14390                         goto out;
14391                 if (ret) {
14392                         if (!trans && repair) {
14393                                 need_trans = 1;
14394                                 key = found_key;
14395                                 btrfs_release_path(&path);
14396                                 goto again;
14397                         }
14398                         bad_roots++;
14399                 }
14400 next:
14401                 path.slots[0]++;
14402         }
14403         ret = 0;
14404 out:
14405         free_roots_info_cache();
14406         btrfs_release_path(&path);
14407         if (trans)
14408                 btrfs_commit_transaction(trans, info->tree_root);
14409         if (ret < 0)
14410                 return ret;
14411
14412         return bad_roots;
14413 }
14414
14415 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
14416 {
14417         struct btrfs_trans_handle *trans;
14418         struct btrfs_block_group_cache *bg_cache;
14419         u64 current = 0;
14420         int ret = 0;
14421
14422         /* Clear all free space cache inodes and its extent data */
14423         while (1) {
14424                 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
14425                 if (!bg_cache)
14426                         break;
14427                 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
14428                 if (ret < 0)
14429                         return ret;
14430                 current = bg_cache->key.objectid + bg_cache->key.offset;
14431         }
14432
14433         /* Don't forget to set cache_generation to -1 */
14434         trans = btrfs_start_transaction(fs_info->tree_root, 0);
14435         if (IS_ERR(trans)) {
14436                 error("failed to update super block cache generation");
14437                 return PTR_ERR(trans);
14438         }
14439         btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
14440         btrfs_commit_transaction(trans, fs_info->tree_root);
14441
14442         return ret;
14443 }
14444
14445 static int do_clear_free_space_cache(struct btrfs_fs_info *fs_info,
14446                 int clear_version)
14447 {
14448         int ret = 0;
14449
14450         if (clear_version == 1) {
14451                 if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
14452                         error(
14453                 "free space cache v2 detected, use --clear-space-cache v2");
14454                         ret = 1;
14455                         goto close_out;
14456                 }
14457                 printf("Clearing free space cache\n");
14458                 ret = clear_free_space_cache(fs_info);
14459                 if (ret) {
14460                         error("failed to clear free space cache");
14461                         ret = 1;
14462                 } else {
14463                         printf("Free space cache cleared\n");
14464                 }
14465         } else if (clear_version == 2) {
14466                 if (!btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
14467                         printf("no free space cache v2 to clear\n");
14468                         ret = 0;
14469                         goto close_out;
14470                 }
14471                 printf("Clear free space cache v2\n");
14472                 ret = btrfs_clear_free_space_tree(fs_info);
14473                 if (ret) {
14474                         error("failed to clear free space cache v2: %d", ret);
14475                         ret = 1;
14476                 } else {
14477                         printf("free space cache v2 cleared\n");
14478                 }
14479         }
14480 close_out:
14481         return ret;
14482 }
14483
14484 const char * const cmd_check_usage[] = {
14485         "btrfs check [options] <device>",
14486         "Check structural integrity of a filesystem (unmounted).",
14487         "Check structural integrity of an unmounted filesystem. Verify internal",
14488         "trees' consistency and item connectivity. In the repair mode try to",
14489         "fix the problems found. ",
14490         "WARNING: the repair mode is considered dangerous",
14491         "",
14492         "-s|--super <superblock>     use this superblock copy",
14493         "-b|--backup                 use the first valid backup root copy",
14494         "--force                     skip mount checks, repair is not possible",
14495         "--repair                    try to repair the filesystem",
14496         "--readonly                  run in read-only mode (default)",
14497         "--init-csum-tree            create a new CRC tree",
14498         "--init-extent-tree          create a new extent tree",
14499         "--mode <MODE>               allows choice of memory/IO trade-offs",
14500         "                            where MODE is one of:",
14501         "                            original - read inodes and extents to memory (requires",
14502         "                                       more memory, does less IO)",
14503         "                            lowmem   - try to use less memory but read blocks again",
14504         "                                       when needed",
14505         "--check-data-csum           verify checksums of data blocks",
14506         "-Q|--qgroup-report          print a report on qgroup consistency",
14507         "-E|--subvol-extents <subvolid>",
14508         "                            print subvolume extents and sharing state",
14509         "-r|--tree-root <bytenr>     use the given bytenr for the tree root",
14510         "--chunk-root <bytenr>       use the given bytenr for the chunk tree root",
14511         "-p|--progress               indicate progress",
14512         "--clear-space-cache v1|v2   clear space cache for v1 or v2",
14513         NULL
14514 };
14515
14516 int cmd_check(int argc, char **argv)
14517 {
14518         struct cache_tree root_cache;
14519         struct btrfs_root *root;
14520         struct btrfs_fs_info *info;
14521         u64 bytenr = 0;
14522         u64 subvolid = 0;
14523         u64 tree_root_bytenr = 0;
14524         u64 chunk_root_bytenr = 0;
14525         char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
14526         int ret = 0;
14527         int err = 0;
14528         u64 num;
14529         int init_csum_tree = 0;
14530         int readonly = 0;
14531         int clear_space_cache = 0;
14532         int qgroup_report = 0;
14533         int qgroups_repaired = 0;
14534         unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
14535         int force = 0;
14536
14537         while(1) {
14538                 int c;
14539                 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
14540                         GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
14541                         GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
14542                         GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE,
14543                         GETOPT_VAL_FORCE };
14544                 static const struct option long_options[] = {
14545                         { "super", required_argument, NULL, 's' },
14546                         { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
14547                         { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
14548                         { "init-csum-tree", no_argument, NULL,
14549                                 GETOPT_VAL_INIT_CSUM },
14550                         { "init-extent-tree", no_argument, NULL,
14551                                 GETOPT_VAL_INIT_EXTENT },
14552                         { "check-data-csum", no_argument, NULL,
14553                                 GETOPT_VAL_CHECK_CSUM },
14554                         { "backup", no_argument, NULL, 'b' },
14555                         { "subvol-extents", required_argument, NULL, 'E' },
14556                         { "qgroup-report", no_argument, NULL, 'Q' },
14557                         { "tree-root", required_argument, NULL, 'r' },
14558                         { "chunk-root", required_argument, NULL,
14559                                 GETOPT_VAL_CHUNK_TREE },
14560                         { "progress", no_argument, NULL, 'p' },
14561                         { "mode", required_argument, NULL,
14562                                 GETOPT_VAL_MODE },
14563                         { "clear-space-cache", required_argument, NULL,
14564                                 GETOPT_VAL_CLEAR_SPACE_CACHE},
14565                         { "force", no_argument, NULL, GETOPT_VAL_FORCE },
14566                         { NULL, 0, NULL, 0}
14567                 };
14568
14569                 c = getopt_long(argc, argv, "as:br:pEQ", long_options, NULL);
14570                 if (c < 0)
14571                         break;
14572                 switch(c) {
14573                         case 'a': /* ignored */ break;
14574                         case 'b':
14575                                 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
14576                                 break;
14577                         case 's':
14578                                 num = arg_strtou64(optarg);
14579                                 if (num >= BTRFS_SUPER_MIRROR_MAX) {
14580                                         error(
14581                                         "super mirror should be less than %d",
14582                                                 BTRFS_SUPER_MIRROR_MAX);
14583                                         exit(1);
14584                                 }
14585                                 bytenr = btrfs_sb_offset(((int)num));
14586                                 printf("using SB copy %llu, bytenr %llu\n", num,
14587                                        (unsigned long long)bytenr);
14588                                 break;
14589                         case 'Q':
14590                                 qgroup_report = 1;
14591                                 break;
14592                         case 'E':
14593                                 subvolid = arg_strtou64(optarg);
14594                                 break;
14595                         case 'r':
14596                                 tree_root_bytenr = arg_strtou64(optarg);
14597                                 break;
14598                         case GETOPT_VAL_CHUNK_TREE:
14599                                 chunk_root_bytenr = arg_strtou64(optarg);
14600                                 break;
14601                         case 'p':
14602                                 ctx.progress_enabled = true;
14603                                 break;
14604                         case '?':
14605                         case 'h':
14606                                 usage(cmd_check_usage);
14607                         case GETOPT_VAL_REPAIR:
14608                                 printf("enabling repair mode\n");
14609                                 repair = 1;
14610                                 ctree_flags |= OPEN_CTREE_WRITES;
14611                                 break;
14612                         case GETOPT_VAL_READONLY:
14613                                 readonly = 1;
14614                                 break;
14615                         case GETOPT_VAL_INIT_CSUM:
14616                                 printf("Creating a new CRC tree\n");
14617                                 init_csum_tree = 1;
14618                                 repair = 1;
14619                                 ctree_flags |= OPEN_CTREE_WRITES;
14620                                 break;
14621                         case GETOPT_VAL_INIT_EXTENT:
14622                                 init_extent_tree = 1;
14623                                 ctree_flags |= (OPEN_CTREE_WRITES |
14624                                                 OPEN_CTREE_NO_BLOCK_GROUPS);
14625                                 repair = 1;
14626                                 break;
14627                         case GETOPT_VAL_CHECK_CSUM:
14628                                 check_data_csum = 1;
14629                                 break;
14630                         case GETOPT_VAL_MODE:
14631                                 check_mode = parse_check_mode(optarg);
14632                                 if (check_mode == CHECK_MODE_UNKNOWN) {
14633                                         error("unknown mode: %s", optarg);
14634                                         exit(1);
14635                                 }
14636                                 break;
14637                         case GETOPT_VAL_CLEAR_SPACE_CACHE:
14638                                 if (strcmp(optarg, "v1") == 0) {
14639                                         clear_space_cache = 1;
14640                                 } else if (strcmp(optarg, "v2") == 0) {
14641                                         clear_space_cache = 2;
14642                                         ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
14643                                 } else {
14644                                         error(
14645                 "invalid argument to --clear-space-cache, must be v1 or v2");
14646                                         exit(1);
14647                                 }
14648                                 ctree_flags |= OPEN_CTREE_WRITES;
14649                                 break;
14650                         case GETOPT_VAL_FORCE:
14651                                 force = 1;
14652                                 break;
14653                 }
14654         }
14655
14656         if (check_argc_exact(argc - optind, 1))
14657                 usage(cmd_check_usage);
14658
14659         if (ctx.progress_enabled) {
14660                 ctx.tp = TASK_NOTHING;
14661                 ctx.info = task_init(print_status_check, print_status_return, &ctx);
14662         }
14663
14664         /* This check is the only reason for --readonly to exist */
14665         if (readonly && repair) {
14666                 error("repair options are not compatible with --readonly");
14667                 exit(1);
14668         }
14669
14670         /*
14671          * experimental and dangerous
14672          */
14673         if (repair && check_mode == CHECK_MODE_LOWMEM)
14674                 warning("low-memory mode repair support is only partial");
14675
14676         radix_tree_init();
14677         cache_tree_init(&root_cache);
14678
14679         ret = check_mounted(argv[optind]);
14680         if (!force) {
14681                 if (ret < 0) {
14682                         error("could not check mount status: %s",
14683                                         strerror(-ret));
14684                         err |= !!ret;
14685                         goto err_out;
14686                 } else if (ret) {
14687                         error(
14688 "%s is currently mounted, use --force if you really intend to check the filesystem",
14689                                 argv[optind]);
14690                         ret = -EBUSY;
14691                         err |= !!ret;
14692                         goto err_out;
14693                 }
14694         } else {
14695                 if (repair) {
14696                         error("repair and --force is not yet supported");
14697                         ret = 1;
14698                         err |= !!ret;
14699                         goto err_out;
14700                 }
14701                 if (ret < 0) {
14702                         warning(
14703 "cannot check mount status of %s, the filesystem could be mounted, continuing because of --force",
14704                                 argv[optind]);
14705                 } else if (ret) {
14706                         warning(
14707                         "filesystem mounted, continuing because of --force");
14708                 }
14709                 /* A block device is mounted in exclusive mode by kernel */
14710                 ctree_flags &= ~OPEN_CTREE_EXCLUSIVE;
14711         }
14712
14713         /* only allow partial opening under repair mode */
14714         if (repair)
14715                 ctree_flags |= OPEN_CTREE_PARTIAL;
14716
14717         info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
14718                                   chunk_root_bytenr, ctree_flags);
14719         if (!info) {
14720                 error("cannot open file system");
14721                 ret = -EIO;
14722                 err |= !!ret;
14723                 goto err_out;
14724         }
14725
14726         global_info = info;
14727         root = info->fs_root;
14728         uuid_unparse(info->super_copy->fsid, uuidbuf);
14729
14730         printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
14731
14732         /*
14733          * Check the bare minimum before starting anything else that could rely
14734          * on it, namely the tree roots, any local consistency checks
14735          */
14736         if (!extent_buffer_uptodate(info->tree_root->node) ||
14737             !extent_buffer_uptodate(info->dev_root->node) ||
14738             !extent_buffer_uptodate(info->chunk_root->node)) {
14739                 error("critical roots corrupted, unable to check the filesystem");
14740                 err |= !!ret;
14741                 ret = -EIO;
14742                 goto close_out;
14743         }
14744
14745         if (clear_space_cache) {
14746                 ret = do_clear_free_space_cache(info, clear_space_cache);
14747                 err |= !!ret;
14748                 goto close_out;
14749         }
14750
14751         /*
14752          * repair mode will force us to commit transaction which
14753          * will make us fail to load log tree when mounting.
14754          */
14755         if (repair && btrfs_super_log_root(info->super_copy)) {
14756                 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
14757                 if (!ret) {
14758                         ret = 1;
14759                         err |= !!ret;
14760                         goto close_out;
14761                 }
14762                 ret = zero_log_tree(root);
14763                 err |= !!ret;
14764                 if (ret) {
14765                         error("failed to zero log tree: %d", ret);
14766                         goto close_out;
14767                 }
14768         }
14769
14770         if (qgroup_report) {
14771                 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
14772                        uuidbuf);
14773                 ret = qgroup_verify_all(info);
14774                 err |= !!ret;
14775                 if (ret == 0)
14776                         report_qgroups(1);
14777                 goto close_out;
14778         }
14779         if (subvolid) {
14780                 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
14781                        subvolid, argv[optind], uuidbuf);
14782                 ret = print_extent_state(info, subvolid);
14783                 err |= !!ret;
14784                 goto close_out;
14785         }
14786
14787         if (init_extent_tree || init_csum_tree) {
14788                 struct btrfs_trans_handle *trans;
14789
14790                 trans = btrfs_start_transaction(info->extent_root, 0);
14791                 if (IS_ERR(trans)) {
14792                         error("error starting transaction");
14793                         ret = PTR_ERR(trans);
14794                         err |= !!ret;
14795                         goto close_out;
14796                 }
14797
14798                 if (init_extent_tree) {
14799                         printf("Creating a new extent tree\n");
14800                         ret = reinit_extent_tree(trans, info);
14801                         err |= !!ret;
14802                         if (ret)
14803                                 goto close_out;
14804                 }
14805
14806                 if (init_csum_tree) {
14807                         printf("Reinitialize checksum tree\n");
14808                         ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
14809                         if (ret) {
14810                                 error("checksum tree initialization failed: %d",
14811                                                 ret);
14812                                 ret = -EIO;
14813                                 err |= !!ret;
14814                                 goto close_out;
14815                         }
14816
14817                         ret = fill_csum_tree(trans, info->csum_root,
14818                                              init_extent_tree);
14819                         err |= !!ret;
14820                         if (ret) {
14821                                 error("checksum tree refilling failed: %d", ret);
14822                                 return -EIO;
14823                         }
14824                 }
14825                 /*
14826                  * Ok now we commit and run the normal fsck, which will add
14827                  * extent entries for all of the items it finds.
14828                  */
14829                 ret = btrfs_commit_transaction(trans, info->extent_root);
14830                 err |= !!ret;
14831                 if (ret)
14832                         goto close_out;
14833         }
14834         if (!extent_buffer_uptodate(info->extent_root->node)) {
14835                 error("critical: extent_root, unable to check the filesystem");
14836                 ret = -EIO;
14837                 err |= !!ret;
14838                 goto close_out;
14839         }
14840         if (!extent_buffer_uptodate(info->csum_root->node)) {
14841                 error("critical: csum_root, unable to check the filesystem");
14842                 ret = -EIO;
14843                 err |= !!ret;
14844                 goto close_out;
14845         }
14846
14847         if (!init_extent_tree) {
14848                 ret = repair_root_items(info);
14849                 if (ret < 0) {
14850                         err = !!ret;
14851                         error("failed to repair root items: %s", strerror(-ret));
14852                         goto close_out;
14853                 }
14854                 if (repair) {
14855                         fprintf(stderr, "Fixed %d roots.\n", ret);
14856                         ret = 0;
14857                 } else if (ret > 0) {
14858                         fprintf(stderr,
14859                                 "Found %d roots with an outdated root item.\n",
14860                                 ret);
14861                         fprintf(stderr,
14862         "Please run a filesystem check with the option --repair to fix them.\n");
14863                         ret = 1;
14864                         err |= ret;
14865                         goto close_out;
14866                 }
14867         }
14868
14869         ret = do_check_chunks_and_extents(info);
14870         err |= !!ret;
14871         if (ret)
14872                 error(
14873                 "errors found in extent allocation tree or chunk allocation");
14874
14875         if (!ctx.progress_enabled) {
14876                 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
14877                         fprintf(stderr, "checking free space tree\n");
14878                 else
14879                         fprintf(stderr, "checking free space cache\n");
14880         }
14881         ret = check_space_cache(root);
14882         err |= !!ret;
14883         if (ret) {
14884                 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
14885                         error("errors found in free space tree");
14886                 else
14887                         error("errors found in free space cache");
14888                 goto out;
14889         }
14890
14891         /*
14892          * We used to have to have these hole extents in between our real
14893          * extents so if we don't have this flag set we need to make sure there
14894          * are no gaps in the file extents for inodes, otherwise we can just
14895          * ignore it when this happens.
14896          */
14897         no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
14898         ret = do_check_fs_roots(info, &root_cache);
14899         err |= !!ret;
14900         if (ret) {
14901                 error("errors found in fs roots");
14902                 goto out;
14903         }
14904
14905         fprintf(stderr, "checking csums\n");
14906         ret = check_csums(root);
14907         err |= !!ret;
14908         if (ret) {
14909                 error("errors found in csum tree");
14910                 goto out;
14911         }
14912
14913         fprintf(stderr, "checking root refs\n");
14914         /* For low memory mode, check_fs_roots_v2 handles root refs */
14915         if (check_mode != CHECK_MODE_LOWMEM) {
14916                 ret = check_root_refs(root, &root_cache);
14917                 err |= !!ret;
14918                 if (ret) {
14919                         error("errors found in root refs");
14920                         goto out;
14921                 }
14922         }
14923
14924         while (repair && !list_empty(&root->fs_info->recow_ebs)) {
14925                 struct extent_buffer *eb;
14926
14927                 eb = list_first_entry(&root->fs_info->recow_ebs,
14928                                       struct extent_buffer, recow);
14929                 list_del_init(&eb->recow);
14930                 ret = recow_extent_buffer(root, eb);
14931                 err |= !!ret;
14932                 if (ret) {
14933                         error("fails to fix transid errors");
14934                         break;
14935                 }
14936         }
14937
14938         while (!list_empty(&delete_items)) {
14939                 struct bad_item *bad;
14940
14941                 bad = list_first_entry(&delete_items, struct bad_item, list);
14942                 list_del_init(&bad->list);
14943                 if (repair) {
14944                         ret = delete_bad_item(root, bad);
14945                         err |= !!ret;
14946                 }
14947                 free(bad);
14948         }
14949
14950         if (info->quota_enabled) {
14951                 fprintf(stderr, "checking quota groups\n");
14952                 ret = qgroup_verify_all(info);
14953                 err |= !!ret;
14954                 if (ret) {
14955                         error("failed to check quota groups");
14956                         goto out;
14957                 }
14958                 report_qgroups(0);
14959                 ret = repair_qgroups(info, &qgroups_repaired);
14960                 err |= !!ret;
14961                 if (err) {
14962                         error("failed to repair quota groups");
14963                         goto out;
14964                 }
14965                 ret = 0;
14966         }
14967
14968         if (!list_empty(&root->fs_info->recow_ebs)) {
14969                 error("transid errors in file system");
14970                 ret = 1;
14971                 err |= !!ret;
14972         }
14973 out:
14974         printf("found %llu bytes used, ",
14975                (unsigned long long)bytes_used);
14976         if (err)
14977                 printf("error(s) found\n");
14978         else
14979                 printf("no error found\n");
14980         printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
14981         printf("total tree bytes: %llu\n",
14982                (unsigned long long)total_btree_bytes);
14983         printf("total fs tree bytes: %llu\n",
14984                (unsigned long long)total_fs_tree_bytes);
14985         printf("total extent tree bytes: %llu\n",
14986                (unsigned long long)total_extent_tree_bytes);
14987         printf("btree space waste bytes: %llu\n",
14988                (unsigned long long)btree_space_waste);
14989         printf("file data blocks allocated: %llu\n referenced %llu\n",
14990                 (unsigned long long)data_bytes_allocated,
14991                 (unsigned long long)data_bytes_referenced);
14992
14993         free_qgroup_counts();
14994         free_root_recs_tree(&root_cache);
14995 close_out:
14996         close_ctree(root);
14997 err_out:
14998         if (ctx.progress_enabled)
14999                 task_deinit(ctx.info);
15000
15001         return err;
15002 }