check/mode-lowmem.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public
   4  * License v2 as published by the Free Software Foundation.
   5  *
   6  * This program is distributed in the hope that it will be useful,
   7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   9  * General Public License for more details.
  10  *
  11  * You should have received a copy of the GNU General Public
  12  * License along with this program; if not, write to the
  13  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14  * Boston, MA 021110-1307, USA.
  15  */
  16
  17 #include <time.h>
  18 #include "ctree.h"
  19 #include "repair.h"
  20 #include "transaction.h"
  21 #include "messages.h"
  22 #include "disk-io.h"
  23 #include "backref.h"
  24 #include "hash.h"
  25 #include "internal.h"
  26 #include "utils.h"
  27 #include "volumes.h"
  28 #include "check/mode-common.h"
  29 #include "check/mode-lowmem.h"
  30
  31 static int calc_extent_flag(struct btrfs_root *root, struct extent_buffer *eb,
  32                             u64 *flags_ret)
  33 {
  34         struct btrfs_root *extent_root = root->fs_info->extent_root;
  35         struct btrfs_root_item *ri = &root->root_item;
  36         struct btrfs_extent_inline_ref *iref;
  37         struct btrfs_extent_item *ei;
  38         struct btrfs_key key;
  39         struct btrfs_path *path = NULL;
  40         unsigned long ptr;
  41         unsigned long end;
  42         u64 flags;
  43         u64 owner = 0;
  44         u64 offset;
  45         int slot;
  46         int type;
  47         int ret = 0;
  48
  49         /*
  50          * Except file/reloc tree, we can not have FULL BACKREF MODE
  51          */
  52         if (root->objectid < BTRFS_FIRST_FREE_OBJECTID)
  53                 goto normal;
  54
  55         /* root node */
  56         if (eb->start == btrfs_root_bytenr(ri))
  57                 goto normal;
  58
  59         if (btrfs_header_flag(eb, BTRFS_HEADER_FLAG_RELOC))
  60                 goto full_backref;
  61
  62         owner = btrfs_header_owner(eb);
  63         if (owner == root->objectid)
  64                 goto normal;
  65
  66         path = btrfs_alloc_path();
  67         if (!path)
  68                 return -ENOMEM;
  69
  70         key.objectid = btrfs_header_bytenr(eb);
  71         key.type = (u8)-1;
  72         key.offset = (u64)-1;
  73
  74         ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
  75         if (ret <= 0) {
  76                 ret = -EIO;
  77                 goto out;
  78         }
  79
  80         if (ret > 0) {
  81                 ret = btrfs_previous_extent_item(extent_root, path,
  82                                                  key.objectid);
  83                 if (ret)
  84                         goto full_backref;
  85
  86         }
  87         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
  88
  89         eb = path->nodes[0];
  90         slot = path->slots[0];
  91         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
  92
  93         flags = btrfs_extent_flags(eb, ei);
  94         if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
  95                 goto full_backref;
  96
  97         ptr = (unsigned long)(ei + 1);
  98         end = (unsigned long)ei + btrfs_item_size_nr(eb, slot);
  99
 100         if (key.type == BTRFS_EXTENT_ITEM_KEY)
 101                 ptr += sizeof(struct btrfs_tree_block_info);
 102
 103 next:
 104         /* Reached extent item ends normally */
 105         if (ptr == end)
 106                 goto full_backref;
 107
 108         /* Beyond extent item end, wrong item size */
 109         if (ptr > end) {
 110                 error("extent item at bytenr %llu slot %d has wrong size",
 111                         eb->start, slot);
 112                 goto full_backref;
 113         }
 114
 115         iref = (struct btrfs_extent_inline_ref *)ptr;
 116         offset = btrfs_extent_inline_ref_offset(eb, iref);
 117         type = btrfs_extent_inline_ref_type(eb, iref);
 118
 119         if (type == BTRFS_TREE_BLOCK_REF_KEY && offset == owner)
 120                 goto normal;
 121         ptr += btrfs_extent_inline_ref_size(type);
 122         goto next;
 123
 124 normal:
 125         *flags_ret &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
 126         goto out;
 127
 128 full_backref:
 129         *flags_ret |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
 130 out:
 131         btrfs_free_path(path);
 132         return ret;
 133 }
 134
 135 /*
 136  * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
 137  * in every fs or file tree check. Here we find its all root ids, and only check
 138  * it in the fs or file tree which has the smallest root id.
 139  */
 140 static int need_check(struct btrfs_root *root, struct ulist *roots)
 141 {
 142         struct rb_node *node;
 143         struct ulist_node *u;
 144
 145         /*
 146          * @roots can be empty if it belongs to tree reloc tree
 147          * In that case, we should always check the leaf, as we can't use
 148          * the tree owner to ensure some other root will check it.
 149          */
 150         if (roots->nnodes == 1 || roots->nnodes == 0)
 151                 return 1;
 152
 153         node = rb_first(&roots->root);
 154         u = rb_entry(node, struct ulist_node, rb_node);
 155         /*
 156          * current root id is not smallest, we skip it and let it be checked
 157          * in the fs or file tree who hash the smallest root id.
 158          */
 159         if (root->objectid != u->val)
 160                 return 0;
 161
 162         return 1;
 163 }
 164
 165 /*
 166  * for a tree node or leaf, we record its reference count, so later if we still
 167  * process this node or leaf, don't need to compute its reference count again.
 168  *
 169  * @bytenr  if @bytenr == (u64)-1, only update nrefs->full_backref[level]
 170  */
 171 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
 172                              struct extent_buffer *eb, struct node_refs *nrefs,
 173                              u64 level, int check_all)
 174 {
 175         struct ulist *roots;
 176         u64 refs = 0;
 177         u64 flags = 0;
 178         int root_level = btrfs_header_level(root->node);
 179         int check;
 180         int ret;
 181
 182         if (nrefs->bytenr[level] == bytenr)
 183                 return 0;
 184
 185         if (bytenr != (u64)-1) {
 186                 /* the return value of this function seems a mistake */
 187                 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
 188                                        level, 1, &refs, &flags);
 189                 /* temporary fix */
 190                 if (ret < 0 && !check_all)
 191                         return ret;
 192
 193                 nrefs->bytenr[level] = bytenr;
 194                 nrefs->refs[level] = refs;
 195                 nrefs->full_backref[level] = 0;
 196                 nrefs->checked[level] = 0;
 197
 198                 if (refs > 1) {
 199                         ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
 200                                                    0, &roots);
 201                         if (ret)
 202                                 return -EIO;
 203
 204                         check = need_check(root, roots);
 205                         ulist_free(roots);
 206                         nrefs->need_check[level] = check;
 207                 } else {
 208                         if (!check_all) {
 209                                 nrefs->need_check[level] = 1;
 210                         } else {
 211                                 if (level == root_level) {
 212                                         nrefs->need_check[level] = 1;
 213                                 } else {
 214                                         /*
 215                                          * The node refs may have not been
 216                                          * updated if upper needs checking (the
 217                                          * lowest root_objectid) the node can
 218                                          * be checked.
 219                                          */
 220                                         nrefs->need_check[level] =
 221                                                 nrefs->need_check[level + 1];
 222                                 }
 223                         }
 224                 }
 225         }
 226
 227         if (check_all && eb) {
 228                 calc_extent_flag(root, eb, &flags);
 229                 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
 230                         nrefs->full_backref[level] = 1;
 231         }
 232
 233         return 0;
 234 }
 235
 236 /*
 237  * This function only handles BACKREF_MISSING,
 238  * If corresponding extent item exists, increase the ref, else insert an extent
 239  * item and backref.
 240  *
 241  * Returns error bits after repair.
 242  */
 243 static int repair_tree_block_ref(struct btrfs_trans_handle *trans,
 244                                  struct btrfs_root *root,
 245                                  struct extent_buffer *node,
 246                                  struct node_refs *nrefs, int level, int err)
 247 {
 248         struct btrfs_fs_info *fs_info = root->fs_info;
 249         struct btrfs_root *extent_root = fs_info->extent_root;
 250         struct btrfs_path path;
 251         struct btrfs_extent_item *ei;
 252         struct btrfs_tree_block_info *bi;
 253         struct btrfs_key key;
 254         struct extent_buffer *eb;
 255         u32 size = sizeof(*ei);
 256         u32 node_size = root->fs_info->nodesize;
 257         int insert_extent = 0;
 258         int skinny_metadata = btrfs_fs_incompat(fs_info, SKINNY_METADATA);
 259         int root_level = btrfs_header_level(root->node);
 260         int generation;
 261         int ret;
 262         u64 owner;
 263         u64 bytenr;
 264         u64 flags = BTRFS_EXTENT_FLAG_TREE_BLOCK;
 265         u64 parent = 0;
 266
 267         if ((err & BACKREF_MISSING) == 0)
 268                 return err;
 269
 270         WARN_ON(level > BTRFS_MAX_LEVEL);
 271         WARN_ON(level < 0);
 272
 273         btrfs_init_path(&path);
 274         bytenr = btrfs_header_bytenr(node);
 275         owner = btrfs_header_owner(node);
 276         generation = btrfs_header_generation(node);
 277
 278         key.objectid = bytenr;
 279         key.type = (u8)-1;
 280         key.offset = (u64)-1;
 281
 282         /* Search for the extent item */
 283         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
 284         if (ret <= 0) {
 285                 ret = -EIO;
 286                 goto out;
 287         }
 288
 289         ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
 290         if (ret)
 291                 insert_extent = 1;
 292
 293         /* calculate if the extent item flag is full backref or not */
 294         if (nrefs->full_backref[level] != 0)
 295                 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
 296
 297         /* insert an extent item */
 298         if (insert_extent) {
 299                 struct btrfs_disk_key copy_key;
 300
 301                 generation = btrfs_header_generation(node);
 302
 303                 if (level < root_level && nrefs->full_backref[level + 1] &&
 304                     owner != root->objectid) {
 305                         flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
 306                 }
 307
 308                 key.objectid = bytenr;
 309                 if (!skinny_metadata) {
 310                         key.type = BTRFS_EXTENT_ITEM_KEY;
 311                         key.offset = node_size;
 312                         size += sizeof(*bi);
 313                 } else {
 314                         key.type = BTRFS_METADATA_ITEM_KEY;
 315                         key.offset = level;
 316                 }
 317
 318                 btrfs_release_path(&path);
 319                 ret = btrfs_insert_empty_item(trans, extent_root, &path, &key,
 320                                               size);
 321                 if (ret)
 322                         goto out;
 323
 324                 eb = path.nodes[0];
 325                 ei = btrfs_item_ptr(eb, path.slots[0], struct btrfs_extent_item);
 326
 327                 btrfs_set_extent_refs(eb, ei, 0);
 328                 btrfs_set_extent_generation(eb, ei, generation);
 329                 btrfs_set_extent_flags(eb, ei, flags);
 330
 331                 if (!skinny_metadata) {
 332                         bi = (struct btrfs_tree_block_info *)(ei + 1);
 333                         memset_extent_buffer(eb, 0, (unsigned long)bi,
 334                                              sizeof(*bi));
 335                         btrfs_set_disk_key_objectid(&copy_key, root->objectid);
 336                         btrfs_set_disk_key_type(&copy_key, 0);
 337                         btrfs_set_disk_key_offset(&copy_key, 0);
 338
 339                         btrfs_set_tree_block_level(eb, bi, level);
 340                         btrfs_set_tree_block_key(eb, bi, &copy_key);
 341                 }
 342                 btrfs_mark_buffer_dirty(eb);
 343                 printf("Added an extent item [%llu %u]\n", bytenr, node_size);
 344                 btrfs_update_block_group(extent_root, bytenr, node_size, 1, 0);
 345
 346                 nrefs->refs[level] = 0;
 347                 nrefs->full_backref[level] =
 348                         flags & BTRFS_BLOCK_FLAG_FULL_BACKREF;
 349                 btrfs_release_path(&path);
 350         }
 351
 352         if (level < root_level && nrefs->full_backref[level + 1] &&
 353             owner != root->objectid)
 354                 parent = nrefs->bytenr[level + 1];
 355
 356         /* increase the ref */
 357         ret = btrfs_inc_extent_ref(trans, extent_root, bytenr, node_size,
 358                         parent, root->objectid, level, 0);
 359
 360         nrefs->refs[level]++;
 361 out:
 362         btrfs_release_path(&path);
 363         if (ret) {
 364                 error(
 365         "failed to repair tree block ref start %llu root %llu due to %s",
 366                       bytenr, root->objectid, strerror(-ret));
 367         } else {
 368                 printf("Added one tree block ref start %llu %s %llu\n",
 369                        bytenr, parent ? "parent" : "root",
 370                        parent ? parent : root->objectid);
 371                 err &= ~BACKREF_MISSING;
 372         }
 373
 374         return err;
 375 }
 376
 377 /*
 378  * Update global fs information.
 379  */
 380 static void account_bytes(struct btrfs_root *root, struct btrfs_path *path,
 381                          int level)
 382 {
 383         u32 free_nrs;
 384         struct extent_buffer *eb = path->nodes[level];
 385
 386         total_btree_bytes += eb->len;
 387         if (fs_root_objectid(root->objectid))
 388                 total_fs_tree_bytes += eb->len;
 389         if (btrfs_header_owner(eb) == BTRFS_EXTENT_TREE_OBJECTID)
 390                 total_extent_tree_bytes += eb->len;
 391
 392         if (level == 0) {
 393                 btree_space_waste += btrfs_leaf_free_space(root, eb);
 394         } else {
 395                 free_nrs = (BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) -
 396                             btrfs_header_nritems(eb));
 397                 btree_space_waste += free_nrs * sizeof(struct btrfs_key_ptr);
 398         }
 399 }
 400
 401 /*
 402  * Find the @index according by @ino and name.
 403  * Notice:time efficiency is O(N)
 404  *
 405  * @root:       the root of the fs/file tree
 406  * @index_ret:  the index as return value
 407  * @namebuf:    the name to match
 408  * @name_len:   the length of name to match
 409  * @file_type:  the file_type of INODE_ITEM to match
 410  *
 411  * Returns 0 if found and *@index_ret will be modified with right value
 412  * Returns< 0 not found and *@index_ret will be (u64)-1
 413  */
 414 static int find_dir_index(struct btrfs_root *root, u64 dirid, u64 location_id,
 415                           u64 *index_ret, char *namebuf, u32 name_len,
 416                           u8 file_type)
 417 {
 418         struct btrfs_path path;
 419         struct extent_buffer *node;
 420         struct btrfs_dir_item *di;
 421         struct btrfs_key key;
 422         struct btrfs_key location;
 423         char name[BTRFS_NAME_LEN] = {0};
 424
 425         u32 total;
 426         u32 cur = 0;
 427         u32 len;
 428         u32 data_len;
 429         u8 filetype;
 430         int slot;
 431         int ret;
 432
 433         ASSERT(index_ret);
 434
 435         /* search from the last index */
 436         key.objectid = dirid;
 437         key.offset = (u64)-1;
 438         key.type = BTRFS_DIR_INDEX_KEY;
 439
 440         btrfs_init_path(&path);
 441         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
 442         if (ret < 0)
 443                 return ret;
 444
 445 loop:
 446         ret = btrfs_previous_item(root, &path, dirid, BTRFS_DIR_INDEX_KEY);
 447         if (ret) {
 448                 ret = -ENOENT;
 449                 *index_ret = (64)-1;
 450                 goto out;
 451         }
 452         /* Check whether inode_id/filetype/name match */
 453         node = path.nodes[0];
 454         slot = path.slots[0];
 455         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
 456         total = btrfs_item_size_nr(node, slot);
 457         while (cur < total) {
 458                 ret = -ENOENT;
 459                 len = btrfs_dir_name_len(node, di);
 460                 data_len = btrfs_dir_data_len(node, di);
 461
 462                 btrfs_dir_item_key_to_cpu(node, di, &location);
 463                 if (location.objectid != location_id ||
 464                     location.type != BTRFS_INODE_ITEM_KEY ||
 465                     location.offset != 0)
 466                         goto next;
 467
 468                 filetype = btrfs_dir_type(node, di);
 469                 if (file_type != filetype)
 470                         goto next;
 471
 472                 if (len > BTRFS_NAME_LEN)
 473                         len = BTRFS_NAME_LEN;
 474
 475                 read_extent_buffer(node, name, (unsigned long)(di + 1), len);
 476                 if (len != name_len || strncmp(namebuf, name, len))
 477                         goto next;
 478
 479                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
 480                 *index_ret = key.offset;
 481                 ret = 0;
 482                 goto out;
 483 next:
 484                 len += sizeof(*di) + data_len;
 485                 di = (struct btrfs_dir_item *)((char *)di + len);
 486                 cur += len;
 487         }
 488         goto loop;
 489
 490 out:
 491         btrfs_release_path(&path);
 492         return ret;
 493 }
 494
 495 /*
 496  * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
 497  * INODE_REF/INODE_EXTREF match.
 498  *
 499  * @root:       the root of the fs/file tree
 500  * @key:        the key of the DIR_ITEM/DIR_INDEX, key->offset will be right
 501  *              value while find index
 502  * @location_key: location key of the struct btrfs_dir_item to match
 503  * @name:       the name to match
 504  * @namelen:    the length of name
 505  * @file_type:  the type of file to math
 506  *
 507  * Return 0 if no error occurred.
 508  * Return DIR_ITEM_MISSING/DIR_INDEX_MISSING if couldn't find
 509  * DIR_ITEM/DIR_INDEX
 510  * Return DIR_ITEM_MISMATCH/DIR_INDEX_MISMATCH if INODE_REF/INODE_EXTREF
 511  * and DIR_ITEM/DIR_INDEX mismatch
 512  */
 513 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *key,
 514                          struct btrfs_key *location_key, char *name,
 515                          u32 namelen, u8 file_type)
 516 {
 517         struct btrfs_path path;
 518         struct extent_buffer *node;
 519         struct btrfs_dir_item *di;
 520         struct btrfs_key location;
 521         char namebuf[BTRFS_NAME_LEN] = {0};
 522         u32 total;
 523         u32 cur = 0;
 524         u32 len;
 525         u32 data_len;
 526         u8 filetype;
 527         int slot;
 528         int ret;
 529
 530         /* get the index by traversing all index */
 531         if (key->type == BTRFS_DIR_INDEX_KEY && key->offset == (u64)-1) {
 532                 ret = find_dir_index(root, key->objectid,
 533                                      location_key->objectid, &key->offset,
 534                                      name, namelen, file_type);
 535                 if (ret)
 536                         ret = DIR_INDEX_MISSING;
 537                 return ret;
 538         }
 539
 540         btrfs_init_path(&path);
 541         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
 542         if (ret) {
 543                 ret = key->type == BTRFS_DIR_ITEM_KEY ? DIR_ITEM_MISSING :
 544                         DIR_INDEX_MISSING;
 545                 goto out;
 546         }
 547
 548         /* Check whether inode_id/filetype/name match */
 549         node = path.nodes[0];
 550         slot = path.slots[0];
 551         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
 552         total = btrfs_item_size_nr(node, slot);
 553         while (cur < total) {
 554                 ret = key->type == BTRFS_DIR_ITEM_KEY ?
 555                         DIR_ITEM_MISMATCH : DIR_INDEX_MISMATCH;
 556
 557                 len = btrfs_dir_name_len(node, di);
 558                 data_len = btrfs_dir_data_len(node, di);
 559
 560                 btrfs_dir_item_key_to_cpu(node, di, &location);
 561                 if (location.objectid != location_key->objectid ||
 562                     location.type != location_key->type ||
 563                     location.offset != location_key->offset)
 564                         goto next;
 565
 566                 filetype = btrfs_dir_type(node, di);
 567                 if (file_type != filetype)
 568                         goto next;
 569
 570                 if (len > BTRFS_NAME_LEN) {
 571                         len = BTRFS_NAME_LEN;
 572                         warning("root %llu %s[%llu %llu] name too long %u, trimmed",
 573                         root->objectid,
 574                         key->type == BTRFS_DIR_ITEM_KEY ?
 575                         "DIR_ITEM" : "DIR_INDEX",
 576                         key->objectid, key->offset, len);
 577                 }
 578                 read_extent_buffer(node, namebuf, (unsigned long)(di + 1),
 579                                    len);
 580                 if (len != namelen || strncmp(namebuf, name, len))
 581                         goto next;
 582
 583                 ret = 0;
 584                 goto out;
 585 next:
 586                 len += sizeof(*di) + data_len;
 587                 di = (struct btrfs_dir_item *)((char *)di + len);
 588                 cur += len;
 589         }
 590
 591 out:
 592         btrfs_release_path(&path);
 593         return ret;
 594 }
 595
 596 /*
 597  * The ternary means dir item, dir index and relative inode ref.
 598  * The function handles errs: INODE_MISSING, DIR_INDEX_MISSING
 599  * DIR_INDEX_MISMATCH, DIR_ITEM_MISSING, DIR_ITEM_MISMATCH by the follow
 600  * strategy:
 601  * If two of three is missing or mismatched, delete the existing one.
 602  * If one of three is missing or mismatched, add the missing one.
 603  *
 604  * returns 0 means success.
 605  * returns not 0 means on error;
 606  */
 607 int repair_ternary_lowmem(struct btrfs_root *root, u64 dir_ino, u64 ino,
 608                           u64 index, char *name, int name_len, u8 filetype,
 609                           int err)
 610 {
 611         struct btrfs_trans_handle *trans;
 612         int stage = 0;
 613         int ret = 0;
 614
 615         /*
 616          * stage shall be one of following valild values:
 617          *      0: Fine, nothing to do.
 618          *      1: One of three is wrong, so add missing one.
 619          *      2: Two of three is wrong, so delete existed one.
 620          */
 621         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING))
 622                 stage++;
 623         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING))
 624                 stage++;
 625         if (err & (INODE_REF_MISSING))
 626                 stage++;
 627
 628         /* stage must be smllarer than 3 */
 629         ASSERT(stage < 3);
 630
 631         trans = btrfs_start_transaction(root, 1);
 632         if (stage == 2) {
 633                 ret = btrfs_unlink(trans, root, ino, dir_ino, index, name,
 634                                    name_len, 0);
 635                 goto out;
 636         }
 637         if (stage == 1) {
 638                 ret = btrfs_add_link(trans, root, ino, dir_ino, name, name_len,
 639                                filetype, &index, 1, 1);
 640                 goto out;
 641         }
 642 out:
 643         btrfs_commit_transaction(trans, root);
 644
 645         if (ret)
 646                 error("fail to repair inode %llu name %s filetype %u",
 647                       ino, name, filetype);
 648         else
 649                 printf("%s ref/dir_item of inode %llu name %s filetype %u\n",
 650                        stage == 2 ? "Delete" : "Add",
 651                        ino, name, filetype);
 652
 653         return ret;
 654 }
 655
 656 /*
 657  * Prints inode ref error message
 658  */
 659 static void print_inode_ref_err(struct btrfs_root *root, struct btrfs_key *key,
 660                                 u64 index, const char *namebuf, int name_len,
 661                                 u8 filetype, int err)
 662 {
 663         if (!err)
 664                 return;
 665
 666         /* root dir error */
 667         if (key->objectid == BTRFS_FIRST_FREE_OBJECTID) {
 668                 error(
 669         "root %llu root dir shouldn't have INODE REF[%llu %llu] name %s",
 670                       root->objectid, key->objectid, key->offset, namebuf);
 671                 return;
 672         }
 673
 674         /* normal error */
 675         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING))
 676                 error("root %llu DIR ITEM[%llu %llu] %s name %s filetype %u",
 677                       root->objectid, key->offset,
 678                       btrfs_name_hash(namebuf, name_len),
 679                       err & DIR_ITEM_MISMATCH ? "mismatch" : "missing",
 680                       namebuf, filetype);
 681         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING))
 682                 error("root %llu DIR INDEX[%llu %llu] %s name %s filetype %u",
 683                       root->objectid, key->offset, index,
 684                       err & DIR_ITEM_MISMATCH ? "mismatch" : "missing",
 685                       namebuf, filetype);
 686 }
 687
 688 /*
 689  * Traverse the given INODE_REF and call find_dir_item() to find related
 690  * DIR_ITEM/DIR_INDEX.
 691  *
 692  * @root:       the root of the fs/file tree
 693  * @ref_key:    the key of the INODE_REF
 694  * @path        the path provides node and slot
 695  * @refs:       the count of INODE_REF
 696  * @mode:       the st_mode of INODE_ITEM
 697  * @name_ret:   returns with the first ref's name
 698  * @name_len_ret:    len of the name_ret
 699  *
 700  * Return 0 if no error occurred.
 701  */
 702 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
 703                            struct btrfs_path *path, char *name_ret,
 704                            u32 *namelen_ret, u64 *refs_ret, int mode)
 705 {
 706         struct btrfs_key key;
 707         struct btrfs_key location;
 708         struct btrfs_inode_ref *ref;
 709         struct extent_buffer *node;
 710         char namebuf[BTRFS_NAME_LEN] = {0};
 711         u32 total;
 712         u32 cur = 0;
 713         u32 len;
 714         u32 name_len;
 715         u64 index;
 716         int ret;
 717         int err = 0;
 718         int tmp_err;
 719         int slot;
 720         int need_research = 0;
 721         u64 refs;
 722
 723 begin:
 724         err = 0;
 725         cur = 0;
 726         refs = *refs_ret;
 727
 728         /* since after repair, path and the dir item may be changed */
 729         if (need_research) {
 730                 need_research = 0;
 731                 btrfs_release_path(path);
 732                 ret = btrfs_search_slot(NULL, root, ref_key, path, 0, 0);
 733                 /*
 734                  * The item was deleted, let the path point to the last checked
 735                  * item.
 736                  */
 737                 if (ret > 0) {
 738                         if (path->slots[0] == 0)
 739                                 btrfs_prev_leaf(root, path);
 740                         else
 741                                 path->slots[0]--;
 742                 }
 743                 if (ret)
 744                         goto out;
 745         }
 746
 747         location.objectid = ref_key->objectid;
 748         location.type = BTRFS_INODE_ITEM_KEY;
 749         location.offset = 0;
 750         node = path->nodes[0];
 751         slot = path->slots[0];
 752
 753         memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
 754         ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
 755         total = btrfs_item_size_nr(node, slot);
 756
 757 next:
 758         /* Update inode ref count */
 759         refs++;
 760         tmp_err = 0;
 761         index = btrfs_inode_ref_index(node, ref);
 762         name_len = btrfs_inode_ref_name_len(node, ref);
 763
 764         if (name_len <= BTRFS_NAME_LEN) {
 765                 len = name_len;
 766         } else {
 767                 len = BTRFS_NAME_LEN;
 768                 warning("root %llu INODE_REF[%llu %llu] name too long",
 769                         root->objectid, ref_key->objectid, ref_key->offset);
 770         }
 771
 772         read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
 773
 774         /* copy the first name found to name_ret */
 775         if (refs == 1 && name_ret) {
 776                 memcpy(name_ret, namebuf, len);
 777                 *namelen_ret = len;
 778         }
 779
 780         /* Check root dir ref */
 781         if (ref_key->objectid == BTRFS_FIRST_FREE_OBJECTID) {
 782                 if (index != 0 || len != strlen("..") ||
 783                     strncmp("..", namebuf, len) ||
 784                     ref_key->offset != BTRFS_FIRST_FREE_OBJECTID) {
 785                         /* set err bits then repair will delete the ref */
 786                         err |= DIR_INDEX_MISSING;
 787                         err |= DIR_ITEM_MISSING;
 788                 }
 789                 goto end;
 790         }
 791
 792         /* Find related DIR_INDEX */
 793         key.objectid = ref_key->offset;
 794         key.type = BTRFS_DIR_INDEX_KEY;
 795         key.offset = index;
 796         tmp_err |= find_dir_item(root, &key, &location, namebuf, len,
 797                             imode_to_type(mode));
 798
 799         /* Find related dir_item */
 800         key.objectid = ref_key->offset;
 801         key.type = BTRFS_DIR_ITEM_KEY;
 802         key.offset = btrfs_name_hash(namebuf, len);
 803         tmp_err |= find_dir_item(root, &key, &location, namebuf, len,
 804                             imode_to_type(mode));
 805 end:
 806         if (tmp_err && repair) {
 807                 ret = repair_ternary_lowmem(root, ref_key->offset,
 808                                             ref_key->objectid, index, namebuf,
 809                                             name_len, imode_to_type(mode),
 810                                             tmp_err);
 811                 if (!ret) {
 812                         need_research = 1;
 813                         goto begin;
 814                 }
 815         }
 816         print_inode_ref_err(root, ref_key, index, namebuf, name_len,
 817                             imode_to_type(mode), tmp_err);
 818         err |= tmp_err;
 819         len = sizeof(*ref) + name_len;
 820         ref = (struct btrfs_inode_ref *)((char *)ref + len);
 821         cur += len;
 822         if (cur < total)
 823                 goto next;
 824
 825 out:
 826         *refs_ret = refs;
 827         return err;
 828 }
 829
 830 /*
 831  * Traverse the given INODE_EXTREF and call find_dir_item() to find related
 832  * DIR_ITEM/DIR_INDEX.
 833  *
 834  * @root:       the root of the fs/file tree
 835  * @ref_key:    the key of the INODE_EXTREF
 836  * @refs:       the count of INODE_EXTREF
 837  * @mode:       the st_mode of INODE_ITEM
 838  *
 839  * Return 0 if no error occurred.
 840  */
 841 static int check_inode_extref(struct btrfs_root *root,
 842                               struct btrfs_key *ref_key,
 843                               struct extent_buffer *node, int slot, u64 *refs,
 844                               int mode)
 845 {
 846         struct btrfs_key key;
 847         struct btrfs_key location;
 848         struct btrfs_inode_extref *extref;
 849         char namebuf[BTRFS_NAME_LEN] = {0};
 850         u32 total;
 851         u32 cur = 0;
 852         u32 len;
 853         u32 name_len;
 854         u64 index;
 855         u64 parent;
 856         int ret;
 857         int err = 0;
 858
 859         location.objectid = ref_key->objectid;
 860         location.type = BTRFS_INODE_ITEM_KEY;
 861         location.offset = 0;
 862
 863         extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
 864         total = btrfs_item_size_nr(node, slot);
 865
 866 next:
 867         /* update inode ref count */
 868         (*refs)++;
 869         name_len = btrfs_inode_extref_name_len(node, extref);
 870         index = btrfs_inode_extref_index(node, extref);
 871         parent = btrfs_inode_extref_parent(node, extref);
 872         if (name_len <= BTRFS_NAME_LEN) {
 873                 len = name_len;
 874         } else {
 875                 len = BTRFS_NAME_LEN;
 876                 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
 877                         root->objectid, ref_key->objectid, ref_key->offset);
 878         }
 879         read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
 880
 881         /* Check root dir ref name */
 882         if (index == 0 && strncmp(namebuf, "..", name_len)) {
 883                 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
 884                       root->objectid, ref_key->objectid, ref_key->offset,
 885                       namebuf);
 886                 err |= ROOT_DIR_ERROR;
 887         }
 888
 889         /* find related dir_index */
 890         key.objectid = parent;
 891         key.type = BTRFS_DIR_INDEX_KEY;
 892         key.offset = index;
 893         ret = find_dir_item(root, &key, &location, namebuf, len, mode);
 894         err |= ret;
 895
 896         /* find related dir_item */
 897         key.objectid = parent;
 898         key.type = BTRFS_DIR_ITEM_KEY;
 899         key.offset = btrfs_name_hash(namebuf, len);
 900         ret = find_dir_item(root, &key, &location, namebuf, len, mode);
 901         err |= ret;
 902
 903         len = sizeof(*extref) + name_len;
 904         extref = (struct btrfs_inode_extref *)((char *)extref + len);
 905         cur += len;
 906
 907         if (cur < total)
 908                 goto next;
 909
 910         return err;
 911 }
 912
 913 /*
 914  * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
 915  * DIR_ITEM/DIR_INDEX match.
 916  * Return with @index_ret.
 917  *
 918  * @root:       the root of the fs/file tree
 919  * @key:        the key of the INODE_REF/INODE_EXTREF
 920  * @name:       the name in the INODE_REF/INODE_EXTREF
 921  * @namelen:    the length of name in the INODE_REF/INODE_EXTREF
 922  * @index_ret:  the index in the INODE_REF/INODE_EXTREF,
 923  *              value (64)-1 means do not check index
 924  * @ext_ref:    the EXTENDED_IREF feature
 925  *
 926  * Return 0 if no error occurred.
 927  * Return >0 for error bitmap
 928  */
 929 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
 930                           char *name, int namelen, u64 *index_ret,
 931                           unsigned int ext_ref)
 932 {
 933         struct btrfs_path path;
 934         struct btrfs_inode_ref *ref;
 935         struct btrfs_inode_extref *extref;
 936         struct extent_buffer *node;
 937         char ref_namebuf[BTRFS_NAME_LEN] = {0};
 938         u32 total;
 939         u32 cur = 0;
 940         u32 len;
 941         u32 ref_namelen;
 942         u64 ref_index;
 943         u64 parent;
 944         u64 dir_id;
 945         int slot;
 946         int ret;
 947
 948         ASSERT(index_ret);
 949
 950         btrfs_init_path(&path);
 951         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
 952         if (ret) {
 953                 ret = INODE_REF_MISSING;
 954                 goto extref;
 955         }
 956
 957         node = path.nodes[0];
 958         slot = path.slots[0];
 959
 960         ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
 961         total = btrfs_item_size_nr(node, slot);
 962
 963         /* Iterate all entry of INODE_REF */
 964         while (cur < total) {
 965                 ret = INODE_REF_MISSING;
 966
 967                 ref_namelen = btrfs_inode_ref_name_len(node, ref);
 968                 ref_index = btrfs_inode_ref_index(node, ref);
 969                 if (*index_ret != (u64)-1 && *index_ret != ref_index)
 970                         goto next_ref;
 971
 972                 if (cur + sizeof(*ref) + ref_namelen > total ||
 973                     ref_namelen > BTRFS_NAME_LEN) {
 974                         warning("root %llu INODE %s[%llu %llu] name too long",
 975                                 root->objectid,
 976                                 key->type == BTRFS_INODE_REF_KEY ?
 977                                         "REF" : "EXTREF",
 978                                 key->objectid, key->offset);
 979
 980                         if (cur + sizeof(*ref) > total)
 981                                 break;
 982                         len = min_t(u32, total - cur - sizeof(*ref),
 983                                     BTRFS_NAME_LEN);
 984                 } else {
 985                         len = ref_namelen;
 986                 }
 987
 988                 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
 989                                    len);
 990
 991                 if (len != namelen || strncmp(ref_namebuf, name, len))
 992                         goto next_ref;
 993
 994                 *index_ret = ref_index;
 995                 ret = 0;
 996                 goto out;
 997 next_ref:
 998                 len = sizeof(*ref) + ref_namelen;
 999                 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1000                 cur += len;
1001         }
1002
1003 extref:
1004         /* Skip if not support EXTENDED_IREF feature */
1005         if (!ext_ref)
1006                 goto out;
1007
1008         btrfs_release_path(&path);
1009         btrfs_init_path(&path);
1010
1011         dir_id = key->offset;
1012         key->type = BTRFS_INODE_EXTREF_KEY;
1013         key->offset = btrfs_extref_hash(dir_id, name, namelen);
1014
1015         ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
1016         if (ret) {
1017                 ret = INODE_REF_MISSING;
1018                 goto out;
1019         }
1020
1021         node = path.nodes[0];
1022         slot = path.slots[0];
1023
1024         extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
1025         cur = 0;
1026         total = btrfs_item_size_nr(node, slot);
1027
1028         /* Iterate all entry of INODE_EXTREF */
1029         while (cur < total) {
1030                 ret = INODE_REF_MISSING;
1031
1032                 ref_namelen = btrfs_inode_extref_name_len(node, extref);
1033                 ref_index = btrfs_inode_extref_index(node, extref);
1034                 parent = btrfs_inode_extref_parent(node, extref);
1035                 if (*index_ret != (u64)-1 && *index_ret != ref_index)
1036                         goto next_extref;
1037
1038                 if (parent != dir_id)
1039                         goto next_extref;
1040
1041                 if (ref_namelen <= BTRFS_NAME_LEN) {
1042                         len = ref_namelen;
1043                 } else {
1044                         len = BTRFS_NAME_LEN;
1045                         warning("root %llu INODE %s[%llu %llu] name too long",
1046                                 root->objectid,
1047                                 key->type == BTRFS_INODE_REF_KEY ?
1048                                         "REF" : "EXTREF",
1049                                 key->objectid, key->offset);
1050                 }
1051                 read_extent_buffer(node, ref_namebuf,
1052                                    (unsigned long)(extref + 1), len);
1053
1054                 if (len != namelen || strncmp(ref_namebuf, name, len))
1055                         goto next_extref;
1056
1057                 *index_ret = ref_index;
1058                 ret = 0;
1059                 goto out;
1060
1061 next_extref:
1062                 len = sizeof(*extref) + ref_namelen;
1063                 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1064                 cur += len;
1065
1066         }
1067 out:
1068         btrfs_release_path(&path);
1069         return ret;
1070 }
1071
1072 static int create_inode_item_lowmem(struct btrfs_trans_handle *trans,
1073                                     struct btrfs_root *root, u64 ino,
1074                                     u8 filetype)
1075 {
1076         u32 mode = (filetype == BTRFS_FT_DIR ? S_IFDIR : S_IFREG) | 0755;
1077
1078         return insert_inode_item(trans, root, ino, 0, 0, 0, mode);
1079 }
1080
1081 /*
1082  * Insert the missing inode item.
1083  *
1084  * Returns 0 means success.
1085  * Returns <0 means error.
1086  */
1087 static int repair_inode_item_missing(struct btrfs_root *root, u64 ino,
1088                                      u8 filetype)
1089 {
1090         struct btrfs_key key;
1091         struct btrfs_trans_handle *trans;
1092         struct btrfs_path path;
1093         int ret;
1094
1095         key.objectid = ino;
1096         key.type = BTRFS_INODE_ITEM_KEY;
1097         key.offset = 0;
1098
1099         btrfs_init_path(&path);
1100         trans = btrfs_start_transaction(root, 1);
1101         if (IS_ERR(trans)) {
1102                 ret = -EIO;
1103                 goto out;
1104         }
1105
1106         ret = btrfs_search_slot(trans, root, &key, &path, 1, 1);
1107         if (ret < 0 || !ret)
1108                 goto fail;
1109
1110         /* insert inode item */
1111         create_inode_item_lowmem(trans, root, ino, filetype);
1112         ret = 0;
1113 fail:
1114         btrfs_commit_transaction(trans, root);
1115 out:
1116         if (ret)
1117                 error("failed to repair root %llu INODE ITEM[%llu] missing",
1118                       root->objectid, ino);
1119         btrfs_release_path(&path);
1120         return ret;
1121 }
1122
1123 /*
1124  * Call repair_inode_item_missing and repair_ternary_lowmem to repair
1125  *
1126  * Returns error after repair
1127  */
1128 static int repair_dir_item(struct btrfs_root *root, u64 dirid, u64 ino,
1129                            u64 index, u8 filetype, char *namebuf, u32 name_len,
1130                            int err)
1131 {
1132         int ret;
1133
1134         if (err & INODE_ITEM_MISSING) {
1135                 ret = repair_inode_item_missing(root, ino, filetype);
1136                 if (!ret)
1137                         err &= ~(INODE_ITEM_MISMATCH | INODE_ITEM_MISSING);
1138         }
1139
1140         if (err & ~(INODE_ITEM_MISMATCH | INODE_ITEM_MISSING)) {
1141                 ret = repair_ternary_lowmem(root, dirid, ino, index, namebuf,
1142                                             name_len, filetype, err);
1143                 if (!ret) {
1144                         err &= ~(DIR_INDEX_MISMATCH | DIR_INDEX_MISSING);
1145                         err &= ~(DIR_ITEM_MISMATCH | DIR_ITEM_MISSING);
1146                         err &= ~(INODE_REF_MISSING);
1147                 }
1148         }
1149         return err;
1150 }
1151
1152 static void print_dir_item_err(struct btrfs_root *root, struct btrfs_key *key,
1153                                u64 ino, u64 index, const char *namebuf,
1154                                int name_len, u8 filetype, int err)
1155 {
1156         if (err & (DIR_ITEM_MISMATCH | DIR_ITEM_MISSING)) {
1157                 error("root %llu DIR ITEM[%llu %llu] name %s filetype %d %s",
1158                       root->objectid, key->objectid, key->offset, namebuf,
1159                       filetype,
1160                       err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
1161         }
1162
1163         if (err & (DIR_INDEX_MISMATCH | DIR_INDEX_MISSING)) {
1164                 error("root %llu DIR INDEX[%llu %llu] name %s filetype %d %s",
1165                       root->objectid, key->objectid, index, namebuf, filetype,
1166                       err & DIR_ITEM_MISMATCH ? "mismath" : "missing");
1167         }
1168
1169         if (err & (INODE_ITEM_MISSING | INODE_ITEM_MISMATCH)) {
1170                 error(
1171                 "root %llu INODE_ITEM[%llu] index %llu name %s filetype %d %s",
1172                       root->objectid, ino, index, namebuf, filetype,
1173                       err & INODE_ITEM_MISMATCH ? "mismath" : "missing");
1174         }
1175
1176         if (err & INODE_REF_MISSING)
1177                 error(
1178                 "root %llu INODE REF[%llu, %llu] name %s filetype %u missing",
1179                       root->objectid, ino, key->objectid, namebuf, filetype);
1180
1181 }
1182
1183 /*
1184  * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
1185  * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
1186  *
1187  * @root:       the root of the fs/file tree
1188  * @key:        the key of the INODE_REF/INODE_EXTREF
1189  * @path:       the path
1190  * @size:       the st_size of the INODE_ITEM
1191  * @ext_ref:    the EXTENDED_IREF feature
1192  *
1193  * Return 0 if no error occurred.
1194  * Return DIR_COUNT_AGAIN if the isize of the inode should be recalculated.
1195  */
1196 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *di_key,
1197                           struct btrfs_path *path, u64 *size,
1198                           unsigned int ext_ref)
1199 {
1200         struct btrfs_dir_item *di;
1201         struct btrfs_inode_item *ii;
1202         struct btrfs_key key;
1203         struct btrfs_key location;
1204         struct extent_buffer *node;
1205         int slot;
1206         char namebuf[BTRFS_NAME_LEN] = {0};
1207         u32 total;
1208         u32 cur = 0;
1209         u32 len;
1210         u32 name_len;
1211         u32 data_len;
1212         u8 filetype;
1213         u32 mode = 0;
1214         u64 index;
1215         int ret;
1216         int err;
1217         int tmp_err;
1218         int need_research = 0;
1219
1220         /*
1221          * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
1222          * ignore index check.
1223          */
1224         if (di_key->type == BTRFS_DIR_INDEX_KEY)
1225                 index = di_key->offset;
1226         else
1227                 index = (u64)-1;
1228 begin:
1229         err = 0;
1230         cur = 0;
1231
1232         /* since after repair, path and the dir item may be changed */
1233         if (need_research) {
1234                 need_research = 0;
1235                 err |= DIR_COUNT_AGAIN;
1236                 btrfs_release_path(path);
1237                 ret = btrfs_search_slot(NULL, root, di_key, path, 0, 0);
1238                 /* the item was deleted, let path point the last checked item */
1239                 if (ret > 0) {
1240                         if (path->slots[0] == 0)
1241                                 btrfs_prev_leaf(root, path);
1242                         else
1243                                 path->slots[0]--;
1244                 }
1245                 if (ret)
1246                         goto out;
1247         }
1248
1249         node = path->nodes[0];
1250         slot = path->slots[0];
1251
1252         di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
1253         total = btrfs_item_size_nr(node, slot);
1254         memset(namebuf, 0, sizeof(namebuf) / sizeof(*namebuf));
1255
1256         while (cur < total) {
1257                 data_len = btrfs_dir_data_len(node, di);
1258                 tmp_err = 0;
1259                 if (data_len)
1260                         error("root %llu %s[%llu %llu] data_len shouldn't be %u",
1261                               root->objectid,
1262               di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
1263                               di_key->objectid, di_key->offset, data_len);
1264
1265                 name_len = btrfs_dir_name_len(node, di);
1266                 if (name_len <= BTRFS_NAME_LEN) {
1267                         len = name_len;
1268                 } else {
1269                         len = BTRFS_NAME_LEN;
1270                         warning("root %llu %s[%llu %llu] name too long",
1271                                 root->objectid,
1272                 di_key->type == BTRFS_DIR_ITEM_KEY ? "DIR_ITEM" : "DIR_INDEX",
1273                                 di_key->objectid, di_key->offset);
1274                 }
1275                 (*size) += name_len;
1276                 read_extent_buffer(node, namebuf, (unsigned long)(di + 1),
1277                                    len);
1278                 filetype = btrfs_dir_type(node, di);
1279
1280                 if (di_key->type == BTRFS_DIR_ITEM_KEY &&
1281                     di_key->offset != btrfs_name_hash(namebuf, len)) {
1282                         err |= -EIO;
1283                         error("root %llu DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
1284                         root->objectid, di_key->objectid, di_key->offset,
1285                         namebuf, len, filetype, di_key->offset,
1286                         btrfs_name_hash(namebuf, len));
1287                 }
1288
1289                 btrfs_dir_item_key_to_cpu(node, di, &location);
1290                 /* Ignore related ROOT_ITEM check */
1291                 if (location.type == BTRFS_ROOT_ITEM_KEY)
1292                         goto next;
1293
1294                 btrfs_release_path(path);
1295                 /* Check relative INODE_ITEM(existence/filetype) */
1296                 ret = btrfs_search_slot(NULL, root, &location, path, 0, 0);
1297                 if (ret) {
1298                         tmp_err |= INODE_ITEM_MISSING;
1299                         goto next;
1300                 }
1301
1302                 ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
1303                                     struct btrfs_inode_item);
1304                 mode = btrfs_inode_mode(path->nodes[0], ii);
1305                 if (imode_to_type(mode) != filetype) {
1306                         tmp_err |= INODE_ITEM_MISMATCH;
1307                         goto next;
1308                 }
1309
1310                 /* Check relative INODE_REF/INODE_EXTREF */
1311                 key.objectid = location.objectid;
1312                 key.type = BTRFS_INODE_REF_KEY;
1313                 key.offset = di_key->objectid;
1314                 tmp_err |= find_inode_ref(root, &key, namebuf, len,
1315                                           &index, ext_ref);
1316
1317                 /* check relative INDEX/ITEM */
1318                 key.objectid = di_key->objectid;
1319                 if (key.type == BTRFS_DIR_ITEM_KEY) {
1320                         key.type = BTRFS_DIR_INDEX_KEY;
1321                         key.offset = index;
1322                 } else {
1323                         key.type = BTRFS_DIR_ITEM_KEY;
1324                         key.offset = btrfs_name_hash(namebuf, name_len);
1325                 }
1326
1327                 tmp_err |= find_dir_item(root, &key, &location, namebuf,
1328                                          name_len, filetype);
1329                 /* find_dir_item may find index */
1330                 if (key.type == BTRFS_DIR_INDEX_KEY)
1331                         index = key.offset;
1332 next:
1333
1334                 if (tmp_err && repair) {
1335                         ret = repair_dir_item(root, di_key->objectid,
1336                                               location.objectid, index,
1337                                               imode_to_type(mode), namebuf,
1338                                               name_len, tmp_err);
1339                         if (ret != tmp_err) {
1340                                 need_research = 1;
1341                                 goto begin;
1342                         }
1343                 }
1344                 btrfs_release_path(path);
1345                 print_dir_item_err(root, di_key, location.objectid, index,
1346                                    namebuf, name_len, filetype, tmp_err);
1347                 err |= tmp_err;
1348                 len = sizeof(*di) + name_len + data_len;
1349                 di = (struct btrfs_dir_item *)((char *)di + len);
1350                 cur += len;
1351
1352                 if (di_key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
1353                         error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
1354                               root->objectid, di_key->objectid,
1355                               di_key->offset);
1356                         break;
1357                 }
1358         }
1359 out:
1360         /* research path */
1361         btrfs_release_path(path);
1362         ret = btrfs_search_slot(NULL, root, di_key, path, 0, 0);
1363         if (ret)
1364                 err |= ret > 0 ? -ENOENT : ret;
1365         return err;
1366 }
1367
1368 /*
1369  * Wrapper function of btrfs_punch_hole.
1370  *
1371  * Returns 0 means success.
1372  * Returns not 0 means error.
1373  */
1374 static int punch_extent_hole(struct btrfs_root *root, u64 ino, u64 start,
1375                              u64 len)
1376 {
1377         struct btrfs_trans_handle *trans;
1378         int ret = 0;
1379
1380         trans = btrfs_start_transaction(root, 1);
1381         if (IS_ERR(trans))
1382                 return PTR_ERR(trans);
1383
1384         ret = btrfs_punch_hole(trans, root, ino, start, len);
1385         if (ret)
1386                 error("failed to add hole [%llu, %llu] in inode [%llu]",
1387                       start, len, ino);
1388         else
1389                 printf("Add a hole [%llu, %llu] in inode [%llu]\n", start, len,
1390                        ino);
1391
1392         btrfs_commit_transaction(trans, root);
1393         return ret;
1394 }
1395
1396 /*
1397  * Check file extent datasum/hole, update the size of the file extents,
1398  * check and update the last offset of the file extent.
1399  *
1400  * @root:       the root of fs/file tree.
1401  * @fkey:       the key of the file extent.
1402  * @nodatasum:  INODE_NODATASUM feature.
1403  * @size:       the sum of all EXTENT_DATA items size for this inode.
1404  * @end:        the offset of the last extent.
1405  *
1406  * Return 0 if no error occurred.
1407  */
1408 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
1409                              struct extent_buffer *node, int slot,
1410                              unsigned int nodatasum, u64 *size, u64 *end)
1411 {
1412         struct btrfs_file_extent_item *fi;
1413         u64 disk_bytenr;
1414         u64 disk_num_bytes;
1415         u64 extent_num_bytes;
1416         u64 extent_offset;
1417         u64 csum_found;         /* In byte size, sectorsize aligned */
1418         u64 search_start;       /* Logical range start we search for csum */
1419         u64 search_len;         /* Logical range len we search for csum */
1420         unsigned int extent_type;
1421         unsigned int is_hole;
1422         int compressed = 0;
1423         int ret;
1424         int err = 0;
1425
1426         fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
1427
1428         /* Check inline extent */
1429         extent_type = btrfs_file_extent_type(node, fi);
1430         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1431                 struct btrfs_item *e = btrfs_item_nr(slot);
1432                 u32 item_inline_len;
1433
1434                 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
1435                 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
1436                 compressed = btrfs_file_extent_compression(node, fi);
1437                 if (extent_num_bytes == 0) {
1438                         error(
1439                 "root %llu EXTENT_DATA[%llu %llu] has empty inline extent",
1440                                 root->objectid, fkey->objectid, fkey->offset);
1441                         err |= FILE_EXTENT_ERROR;
1442                 }
1443                 if (!compressed && extent_num_bytes != item_inline_len) {
1444                         error(
1445                 "root %llu EXTENT_DATA[%llu %llu] wrong inline size, have: %llu, expected: %u",
1446                                 root->objectid, fkey->objectid, fkey->offset,
1447                                 extent_num_bytes, item_inline_len);
1448                         err |= FILE_EXTENT_ERROR;
1449                 }
1450                 *end += extent_num_bytes;
1451                 *size += extent_num_bytes;
1452                 return err;
1453         }
1454
1455         /* Check extent type */
1456         if (extent_type != BTRFS_FILE_EXTENT_REG &&
1457                         extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
1458                 err |= FILE_EXTENT_ERROR;
1459                 error("root %llu EXTENT_DATA[%llu %llu] type bad",
1460                       root->objectid, fkey->objectid, fkey->offset);
1461                 return err;
1462         }
1463
1464         /* Check REG_EXTENT/PREALLOC_EXTENT */
1465         disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
1466         disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
1467         extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
1468         extent_offset = btrfs_file_extent_offset(node, fi);
1469         compressed = btrfs_file_extent_compression(node, fi);
1470         is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
1471
1472         /*
1473          * Check EXTENT_DATA csum
1474          *
1475          * For plain (uncompressed) extent, we should only check the range
1476          * we're referring to, as it's possible that part of prealloc extent
1477          * has been written, and has csum:
1478          *
1479          * |<--- Original large preallocated extent A ---->|
1480          * |<- Prealloc File Extent ->|<- Regular Extent ->|
1481          *      No csum                         Has csum
1482          *
1483          * For compressed extent, we should check the whole range.
1484          */
1485         if (!compressed) {
1486                 search_start = disk_bytenr + extent_offset;
1487                 search_len = extent_num_bytes;
1488         } else {
1489                 search_start = disk_bytenr;
1490                 search_len = disk_num_bytes;
1491         }
1492         ret = count_csum_range(root->fs_info, search_start, search_len,
1493                                &csum_found);
1494         if (csum_found > 0 && nodatasum) {
1495                 err |= ODD_CSUM_ITEM;
1496                 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
1497                       root->objectid, fkey->objectid, fkey->offset);
1498         } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
1499                    !is_hole && (ret < 0 || csum_found < search_len)) {
1500                 err |= CSUM_ITEM_MISSING;
1501                 error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
1502                       root->objectid, fkey->objectid, fkey->offset,
1503                       csum_found, search_len);
1504         } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1505                    csum_found > 0) {
1506                 ret = check_prealloc_extent_written(root->fs_info,
1507                                                     disk_bytenr, disk_num_bytes);
1508                 if (ret < 0)
1509                         return ret;
1510                 if (ret == 0) {
1511                         err |= ODD_CSUM_ITEM;
1512                         error(
1513 "root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
1514                               root->objectid, fkey->objectid, fkey->offset,
1515                               csum_found);
1516                 }
1517         }
1518
1519         /* Check EXTENT_DATA hole */
1520         if (!no_holes && *end != fkey->offset) {
1521                 if (repair)
1522                         ret = punch_extent_hole(root, fkey->objectid,
1523                                                 *end, fkey->offset - *end);
1524                 if (!repair || ret) {
1525                         err |= FILE_EXTENT_ERROR;
1526                         error(
1527 "root %llu EXTENT_DATA[%llu %llu] gap exists, expected: EXTENT_DATA[%llu %llu]",
1528                                 root->objectid, fkey->objectid, fkey->offset,
1529                                 fkey->objectid, *end);
1530                 }
1531         }
1532
1533         *end += extent_num_bytes;
1534         if (!is_hole)
1535                 *size += extent_num_bytes;
1536
1537         return err;
1538 }
1539
1540 static int __count_dir_isize(struct btrfs_root *root, u64 ino, int type,
1541                 u64 *size_ret)
1542 {
1543         struct btrfs_key key;
1544         struct btrfs_path path;
1545         u32 len;
1546         struct btrfs_dir_item *di;
1547         int ret;
1548         int cur = 0;
1549         int total = 0;
1550
1551         ASSERT(size_ret);
1552         *size_ret = 0;
1553
1554         key.objectid = ino;
1555         key.type = type;
1556         key.offset = (u64)-1;
1557
1558         btrfs_init_path(&path);
1559         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1560         if (ret < 0) {
1561                 ret = -EIO;
1562                 goto out;
1563         }
1564         /* if found, go to spacial case */
1565         if (ret == 0)
1566                 goto special_case;
1567
1568 loop:
1569         ret = btrfs_previous_item(root, &path, ino, type);
1570
1571         if (ret) {
1572                 ret = 0;
1573                 goto out;
1574         }
1575
1576 special_case:
1577         di = btrfs_item_ptr(path.nodes[0], path.slots[0], struct btrfs_dir_item);
1578         cur = 0;
1579         total = btrfs_item_size_nr(path.nodes[0], path.slots[0]);
1580
1581         while (cur < total) {
1582                 len = btrfs_dir_name_len(path.nodes[0], di);
1583                 if (len > BTRFS_NAME_LEN)
1584                         len = BTRFS_NAME_LEN;
1585                 *size_ret += len;
1586
1587                 len += btrfs_dir_data_len(path.nodes[0], di);
1588                 len += sizeof(*di);
1589                 di = (struct btrfs_dir_item *)((char *)di + len);
1590                 cur += len;
1591         }
1592         goto loop;
1593
1594 out:
1595         btrfs_release_path(&path);
1596         return ret;
1597 }
1598
1599 static int count_dir_isize(struct btrfs_root *root, u64 ino, u64 *size)
1600 {
1601         u64 item_size;
1602         u64 index_size;
1603         int ret;
1604
1605         ASSERT(size);
1606         ret = __count_dir_isize(root, ino, BTRFS_DIR_ITEM_KEY, &item_size);
1607         if (ret)
1608                 goto out;
1609
1610         ret = __count_dir_isize(root, ino, BTRFS_DIR_INDEX_KEY, &index_size);
1611         if (ret)
1612                 goto out;
1613
1614         *size = item_size + index_size;
1615
1616 out:
1617         if (ret)
1618                 error("failed to count root %llu INODE[%llu] root size",
1619                       root->objectid, ino);
1620         return ret;
1621 }
1622
1623 /*
1624  * Set inode item nbytes to @nbytes
1625  *
1626  * Returns  0     on success
1627  * Returns  != 0  on error
1628  */
1629 static int repair_inode_nbytes_lowmem(struct btrfs_root *root,
1630                                       struct btrfs_path *path,
1631                                       u64 ino, u64 nbytes)
1632 {
1633         struct btrfs_trans_handle *trans;
1634         struct btrfs_inode_item *ii;
1635         struct btrfs_key key;
1636         struct btrfs_key research_key;
1637         int err = 0;
1638         int ret;
1639
1640         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
1641
1642         key.objectid = ino;
1643         key.type = BTRFS_INODE_ITEM_KEY;
1644         key.offset = 0;
1645
1646         trans = btrfs_start_transaction(root, 1);
1647         if (IS_ERR(trans)) {
1648                 ret = PTR_ERR(trans);
1649                 err |= ret;
1650                 goto out;
1651         }
1652
1653         btrfs_release_path(path);
1654         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1655         if (ret > 0)
1656                 ret = -ENOENT;
1657         if (ret) {
1658                 err |= ret;
1659                 goto fail;
1660         }
1661
1662         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
1663                             struct btrfs_inode_item);
1664         btrfs_set_inode_nbytes(path->nodes[0], ii, nbytes);
1665         btrfs_mark_buffer_dirty(path->nodes[0]);
1666 fail:
1667         btrfs_commit_transaction(trans, root);
1668 out:
1669         if (ret)
1670                 error("failed to set nbytes in inode %llu root %llu",
1671                       ino, root->root_key.objectid);
1672         else
1673                 printf("Set nbytes in inode item %llu root %llu\n to %llu", ino,
1674                        root->root_key.objectid, nbytes);
1675
1676         /* research path */
1677         btrfs_release_path(path);
1678         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
1679         err |= ret;
1680
1681         return err;
1682 }
1683
1684 /*
1685  * Set directory inode isize to @isize.
1686  *
1687  * Returns 0     on success.
1688  * Returns != 0  on error.
1689  */
1690 static int repair_dir_isize_lowmem(struct btrfs_root *root,
1691                                    struct btrfs_path *path,
1692                                    u64 ino, u64 isize)
1693 {
1694         struct btrfs_trans_handle *trans;
1695         struct btrfs_inode_item *ii;
1696         struct btrfs_key key;
1697         struct btrfs_key research_key;
1698         int ret;
1699         int err = 0;
1700
1701         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
1702
1703         key.objectid = ino;
1704         key.type = BTRFS_INODE_ITEM_KEY;
1705         key.offset = 0;
1706
1707         trans = btrfs_start_transaction(root, 1);
1708         if (IS_ERR(trans)) {
1709                 ret = PTR_ERR(trans);
1710                 err |= ret;
1711                 goto out;
1712         }
1713
1714         btrfs_release_path(path);
1715         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1716         if (ret > 0)
1717                 ret = -ENOENT;
1718         if (ret) {
1719                 err |= ret;
1720                 goto fail;
1721         }
1722
1723         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
1724                             struct btrfs_inode_item);
1725         btrfs_set_inode_size(path->nodes[0], ii, isize);
1726         btrfs_mark_buffer_dirty(path->nodes[0]);
1727 fail:
1728         btrfs_commit_transaction(trans, root);
1729 out:
1730         if (ret)
1731                 error("failed to set isize in inode %llu root %llu",
1732                       ino, root->root_key.objectid);
1733         else
1734                 printf("Set isize in inode %llu root %llu to %llu\n",
1735                        ino, root->root_key.objectid, isize);
1736
1737         btrfs_release_path(path);
1738         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
1739         err |= ret;
1740
1741         return err;
1742 }
1743
1744 /*
1745  * Wrapper function for btrfs_add_orphan_item().
1746  *
1747  * Returns 0     on success.
1748  * Returns != 0  on error.
1749  */
1750 static int repair_inode_orphan_item_lowmem(struct btrfs_root *root,
1751                                            struct btrfs_path *path, u64 ino)
1752 {
1753         struct btrfs_trans_handle *trans;
1754         struct btrfs_key research_key;
1755         int ret;
1756         int err = 0;
1757
1758         btrfs_item_key_to_cpu(path->nodes[0], &research_key, path->slots[0]);
1759
1760         trans = btrfs_start_transaction(root, 1);
1761         if (IS_ERR(trans)) {
1762                 ret = PTR_ERR(trans);
1763                 err |= ret;
1764                 goto out;
1765         }
1766
1767         btrfs_release_path(path);
1768         ret = btrfs_add_orphan_item(trans, root, path, ino);
1769         err |= ret;
1770         btrfs_commit_transaction(trans, root);
1771 out:
1772         if (ret)
1773                 error("failed to add inode %llu as orphan item root %llu",
1774                       ino, root->root_key.objectid);
1775         else
1776                 printf("Added inode %llu as orphan item root %llu\n",
1777                        ino, root->root_key.objectid);
1778
1779         btrfs_release_path(path);
1780         ret = btrfs_search_slot(NULL, root, &research_key, path, 0, 0);
1781         err |= ret;
1782
1783         return err;
1784 }
1785
1786 /* Set inode_item nlink to @ref_count.
1787  * If @ref_count == 0, move it to "lost+found" and increase @ref_count.
1788  *
1789  * Returns 0 on success
1790  */
1791 static int repair_inode_nlinks_lowmem(struct btrfs_root *root,
1792                                       struct btrfs_path *path, u64 ino,
1793                                       const char *name, u32 namelen,
1794                                       u64 ref_count, u8 filetype, u64 *nlink)
1795 {
1796         struct btrfs_trans_handle *trans;
1797         struct btrfs_inode_item *ii;
1798         struct btrfs_key key;
1799         struct btrfs_key old_key;
1800         char namebuf[BTRFS_NAME_LEN] = {0};
1801         int name_len;
1802         int ret;
1803         int ret2;
1804
1805         /* save the key */
1806         btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]);
1807
1808         if (name && namelen) {
1809                 ASSERT(namelen <= BTRFS_NAME_LEN);
1810                 memcpy(namebuf, name, namelen);
1811                 name_len = namelen;
1812         } else {
1813                 sprintf(namebuf, "%llu", ino);
1814                 name_len = count_digits(ino);
1815                 printf("Can't find file name for inode %llu, use %s instead\n",
1816                        ino, namebuf);
1817         }
1818
1819         trans = btrfs_start_transaction(root, 1);
1820         if (IS_ERR(trans)) {
1821                 ret = PTR_ERR(trans);
1822                 goto out;
1823         }
1824
1825         btrfs_release_path(path);
1826         /* if refs is 0, put it into lostfound */
1827         if (ref_count == 0) {
1828                 ret = link_inode_to_lostfound(trans, root, path, ino, namebuf,
1829                                               name_len, filetype, &ref_count);
1830                 if (ret)
1831                         goto fail;
1832         }
1833
1834         /* reset inode_item's nlink to ref_count */
1835         key.objectid = ino;
1836         key.type = BTRFS_INODE_ITEM_KEY;
1837         key.offset = 0;
1838
1839         btrfs_release_path(path);
1840         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
1841         if (ret > 0)
1842                 ret = -ENOENT;
1843         if (ret)
1844                 goto fail;
1845
1846         ii = btrfs_item_ptr(path->nodes[0], path->slots[0],
1847                             struct btrfs_inode_item);
1848         btrfs_set_inode_nlink(path->nodes[0], ii, ref_count);
1849         btrfs_mark_buffer_dirty(path->nodes[0]);
1850
1851         if (nlink)
1852                 *nlink = ref_count;
1853 fail:
1854         btrfs_commit_transaction(trans, root);
1855 out:
1856         if (ret)
1857                 error(
1858         "fail to repair nlink of inode %llu root %llu name %s filetype %u",
1859                        root->objectid, ino, namebuf, filetype);
1860         else
1861                 printf("Fixed nlink of inode %llu root %llu name %s filetype %u\n",
1862                        root->objectid, ino, namebuf, filetype);
1863
1864         /* research */
1865         btrfs_release_path(path);
1866         ret2 = btrfs_search_slot(NULL, root, &old_key, path, 0, 0);
1867         if (ret2 < 0)
1868                 return ret |= ret2;
1869         return ret;
1870 }
1871
1872 static bool has_orphan_item(struct btrfs_root *root, u64 ino)
1873 {
1874         struct btrfs_path path;
1875         struct btrfs_key key;
1876         int ret;
1877
1878         btrfs_init_path(&path);
1879         key.objectid = BTRFS_ORPHAN_OBJECTID;
1880         key.type = BTRFS_ORPHAN_ITEM_KEY;
1881         key.offset = ino;
1882
1883         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1884         btrfs_release_path(&path);
1885         if (ret == 0)
1886                 return true;
1887         return false;
1888 }
1889
1890 /*
1891  * Check INODE_ITEM and related ITEMs (the same inode number)
1892  * 1. check link count
1893  * 2. check inode ref/extref
1894  * 3. check dir item/index
1895  *
1896  * @ext_ref:    the EXTENDED_IREF feature
1897  *
1898  * Return 0 if no error occurred.
1899  * Return >0 for error or hit the traversal is done(by error bitmap)
1900  */
1901 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1902                             unsigned int ext_ref)
1903 {
1904         struct extent_buffer *node;
1905         struct btrfs_inode_item *ii;
1906         struct btrfs_key key;
1907         struct btrfs_key last_key;
1908         u64 inode_id;
1909         u32 mode;
1910         u64 nlink;
1911         u64 nbytes;
1912         u64 isize;
1913         u64 size = 0;
1914         u64 refs = 0;
1915         u64 extent_end = 0;
1916         u64 extent_size = 0;
1917         unsigned int dir;
1918         unsigned int nodatasum;
1919         bool is_orphan = false;
1920         int slot;
1921         int ret;
1922         int err = 0;
1923         char namebuf[BTRFS_NAME_LEN] = {0};
1924         u32 name_len = 0;
1925
1926         node = path->nodes[0];
1927         slot = path->slots[0];
1928
1929         btrfs_item_key_to_cpu(node, &key, slot);
1930         inode_id = key.objectid;
1931
1932         if (inode_id == BTRFS_ORPHAN_OBJECTID) {
1933                 ret = btrfs_next_item(root, path);
1934                 if (ret > 0)
1935                         err |= LAST_ITEM;
1936                 return err;
1937         }
1938
1939         ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
1940         isize = btrfs_inode_size(node, ii);
1941         nbytes = btrfs_inode_nbytes(node, ii);
1942         mode = btrfs_inode_mode(node, ii);
1943         dir = imode_to_type(mode) == BTRFS_FT_DIR;
1944         nlink = btrfs_inode_nlink(node, ii);
1945         nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
1946
1947         while (1) {
1948                 btrfs_item_key_to_cpu(path->nodes[0], &last_key, path->slots[0]);
1949                 ret = btrfs_next_item(root, path);
1950                 if (ret < 0) {
1951                         /* out will fill 'err' rusing current statistics */
1952                         goto out;
1953                 } else if (ret > 0) {
1954                         err |= LAST_ITEM;
1955                         goto out;
1956                 }
1957
1958                 node = path->nodes[0];
1959                 slot = path->slots[0];
1960                 btrfs_item_key_to_cpu(node, &key, slot);
1961                 if (key.objectid != inode_id)
1962                         goto out;
1963
1964                 switch (key.type) {
1965                 case BTRFS_INODE_REF_KEY:
1966                         ret = check_inode_ref(root, &key, path, namebuf,
1967                                               &name_len, &refs, mode);
1968                         err |= ret;
1969                         break;
1970                 case BTRFS_INODE_EXTREF_KEY:
1971                         if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
1972                                 warning("root %llu EXTREF[%llu %llu] isn't supported",
1973                                         root->objectid, key.objectid,
1974                                         key.offset);
1975                         ret = check_inode_extref(root, &key, node, slot, &refs,
1976                                                  mode);
1977                         err |= ret;
1978                         break;
1979                 case BTRFS_DIR_ITEM_KEY:
1980                 case BTRFS_DIR_INDEX_KEY:
1981                         if (!dir) {
1982                                 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
1983                                         root->objectid, inode_id,
1984                                         imode_to_type(mode), key.objectid,
1985                                         key.offset);
1986                         }
1987                         ret = check_dir_item(root, &key, path, &size, ext_ref);
1988                         err |= ret;
1989                         break;
1990                 case BTRFS_EXTENT_DATA_KEY:
1991                         if (dir) {
1992                                 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
1993                                         root->objectid, inode_id, key.objectid,
1994                                         key.offset);
1995                         }
1996                         ret = check_file_extent(root, &key, node, slot,
1997                                                 nodatasum, &extent_size,
1998                                                 &extent_end);
1999                         err |= ret;
2000                         break;
2001                 case BTRFS_XATTR_ITEM_KEY:
2002                         break;
2003                 default:
2004                         error("ITEM[%llu %u %llu] UNKNOWN TYPE",
2005                               key.objectid, key.type, key.offset);
2006                 }
2007         }
2008
2009 out:
2010         if (err & LAST_ITEM) {
2011                 btrfs_release_path(path);
2012                 ret = btrfs_search_slot(NULL, root, &last_key, path, 0, 0);
2013                 if (ret)
2014                         return err;
2015         }
2016
2017         /* verify INODE_ITEM nlink/isize/nbytes */
2018         if (dir) {
2019                 if (repair && (err & DIR_COUNT_AGAIN)) {
2020                         err &= ~DIR_COUNT_AGAIN;
2021                         count_dir_isize(root, inode_id, &size);
2022                 }
2023
2024                 if ((nlink != 1 || refs != 1) && repair) {
2025                         ret = repair_inode_nlinks_lowmem(root, path, inode_id,
2026                                 namebuf, name_len, refs, imode_to_type(mode),
2027                                 &nlink);
2028                 }
2029
2030                 if (nlink != 1) {
2031                         err |= LINK_COUNT_ERROR;
2032                         error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
2033                               root->objectid, inode_id, nlink);
2034                 }
2035
2036                 /*
2037                  * Just a warning, as dir inode nbytes is just an
2038                  * instructive value.
2039                  */
2040                 if (!IS_ALIGNED(nbytes, root->fs_info->nodesize)) {
2041                         warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
2042                                 root->objectid, inode_id,
2043                                 root->fs_info->nodesize);
2044                 }
2045
2046                 if (isize != size) {
2047                         if (repair)
2048                                 ret = repair_dir_isize_lowmem(root, path,
2049                                                               inode_id, size);
2050                         if (!repair || ret) {
2051                                 err |= ISIZE_ERROR;
2052                                 error(
2053                 "root %llu DIR INODE [%llu] size %llu not equal to %llu",
2054                                       root->objectid, inode_id, isize, size);
2055                         }
2056                 }
2057         } else {
2058                 if (nlink != refs) {
2059                         if (repair)
2060                                 ret = repair_inode_nlinks_lowmem(root, path,
2061                                          inode_id, namebuf, name_len, refs,
2062                                          imode_to_type(mode), &nlink);
2063                         if (!repair || ret) {
2064                                 err |= LINK_COUNT_ERROR;
2065                                 error(
2066                 "root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
2067                                       root->objectid, inode_id, nlink, refs);
2068                         }
2069                 } else if (!nlink) {
2070                         is_orphan = has_orphan_item(root, inode_id);
2071                         if (!is_orphan && repair)
2072                                 ret = repair_inode_orphan_item_lowmem(root,
2073                                                               path, inode_id);
2074                         if (!is_orphan && (!repair || ret)) {
2075                                 err |= ORPHAN_ITEM;
2076                                 error("root %llu INODE[%llu] is orphan item",
2077                                       root->objectid, inode_id);
2078                         }
2079                 }
2080
2081                 if (!nbytes && !no_holes && extent_end < isize) {
2082                         if (repair)
2083                                 ret = punch_extent_hole(root, inode_id,
2084                                                 extent_end, isize - extent_end);
2085                         if (!repair || ret) {
2086                                 err |= NBYTES_ERROR;
2087                                 error(
2088         "root %llu INODE[%llu] size %llu should have a file extent hole",
2089                                       root->objectid, inode_id, isize);
2090                         }
2091                 }
2092
2093                 if (nbytes != extent_size) {
2094                         if (repair)
2095                                 ret = repair_inode_nbytes_lowmem(root, path,
2096                                                          inode_id, extent_size);
2097                         if (!repair || ret) {
2098                                 err |= NBYTES_ERROR;
2099                                 error(
2100         "root %llu INODE[%llu] nbytes %llu not equal to extent_size %llu",
2101                                       root->objectid, inode_id, nbytes,
2102                                       extent_size);
2103                         }
2104                 }
2105         }
2106
2107         if (err & LAST_ITEM)
2108                 btrfs_next_item(root, path);
2109         return err;
2110 }
2111
2112 /*
2113  * Returns >0  Found error, not fatal, should continue
2114  * Returns <0  Fatal error, must exit the whole check
2115  * Returns 0   No errors found
2116  */
2117 static int process_one_leaf(struct btrfs_root *root, struct btrfs_path *path,
2118                             struct node_refs *nrefs, int *level, int ext_ref)
2119 {
2120         struct extent_buffer *cur = path->nodes[0];
2121         struct btrfs_key key;
2122         u64 cur_bytenr;
2123         u32 nritems;
2124         u64 first_ino = 0;
2125         int root_level = btrfs_header_level(root->node);
2126         int i;
2127         int ret = 0; /* Final return value */
2128         int err = 0; /* Positive error bitmap */
2129
2130         cur_bytenr = cur->start;
2131
2132         /* skip to first inode item or the first inode number change */
2133         nritems = btrfs_header_nritems(cur);
2134         for (i = 0; i < nritems; i++) {
2135                 btrfs_item_key_to_cpu(cur, &key, i);
2136                 if (i == 0)
2137                         first_ino = key.objectid;
2138                 if (key.type == BTRFS_INODE_ITEM_KEY ||
2139                     (first_ino && first_ino != key.objectid))
2140                         break;
2141         }
2142         if (i == nritems) {
2143                 path->slots[0] = nritems;
2144                 return 0;
2145         }
2146         path->slots[0] = i;
2147
2148 again:
2149         err |= check_inode_item(root, path, ext_ref);
2150
2151         /* modify cur since check_inode_item may change path */
2152         cur = path->nodes[0];
2153
2154         if (err & LAST_ITEM)
2155                 goto out;
2156
2157         /* still have inode items in thie leaf */
2158         if (cur->start == cur_bytenr)
2159                 goto again;
2160
2161         /*
2162          * we have switched to another leaf, above nodes may
2163          * have changed, here walk down the path, if a node
2164          * or leaf is shared, check whether we can skip this
2165          * node or leaf.
2166          */
2167         for (i = root_level; i >= 0; i--) {
2168                 if (path->nodes[i]->start == nrefs->bytenr[i])
2169                         continue;
2170
2171                 ret = update_nodes_refs(root, path->nodes[i]->start,
2172                                 path->nodes[i], nrefs, i, 0);
2173                 if (ret)
2174                         goto out;
2175
2176                 if (!nrefs->need_check[i]) {
2177                         *level += 1;
2178                         break;
2179                 }
2180         }
2181
2182         for (i = 0; i < *level; i++) {
2183                 free_extent_buffer(path->nodes[i]);
2184                 path->nodes[i] = NULL;
2185         }
2186 out:
2187         err &= ~LAST_ITEM;
2188         if (err && !ret)
2189                 ret = err;
2190         return ret;
2191 }
2192
2193 /*
2194  * @level           if @level == -1 means extent data item
2195  *                  else normal treeblocl.
2196  */
2197 static int should_check_extent_strictly(struct btrfs_root *root,
2198                                         struct node_refs *nrefs, int level)
2199 {
2200         int root_level = btrfs_header_level(root->node);
2201
2202         if (level > root_level || level < -1)
2203                 return 1;
2204         if (level == root_level)
2205                 return 1;
2206         /*
2207          * if the upper node is marked full backref, it should contain shared
2208          * backref of the parent (except owner == root->objectid).
2209          */
2210         while (++level <= root_level)
2211                 if (nrefs->refs[level] > 1)
2212                         return 0;
2213
2214         return 1;
2215 }
2216
2217 static int check_extent_inline_ref(struct extent_buffer *eb,
2218                    struct btrfs_key *key, struct btrfs_extent_inline_ref *iref)
2219 {
2220         int ret;
2221         u8 type = btrfs_extent_inline_ref_type(eb, iref);
2222
2223         switch (type) {
2224         case BTRFS_TREE_BLOCK_REF_KEY:
2225         case BTRFS_EXTENT_DATA_REF_KEY:
2226         case BTRFS_SHARED_BLOCK_REF_KEY:
2227         case BTRFS_SHARED_DATA_REF_KEY:
2228                 ret = 0;
2229                 break;
2230         default:
2231                 error("extent[%llu %u %llu] has unknown ref type: %d",
2232                       key->objectid, key->type, key->offset, type);
2233                 ret = UNKNOWN_TYPE;
2234                 break;
2235         }
2236
2237         return ret;
2238 }
2239
2240 /*
2241  * Check backrefs of a tree block given by @bytenr or @eb.
2242  *
2243  * @root:       the root containing the @bytenr or @eb
2244  * @eb:         tree block extent buffer, can be NULL
2245  * @bytenr:     bytenr of the tree block to search
2246  * @level:      tree level of the tree block
2247  * @owner:      owner of the tree block
2248  *
2249  * Return >0 for any error found and output error message
2250  * Return 0 for no error found
2251  */
2252 static int check_tree_block_ref(struct btrfs_root *root,
2253                                 struct extent_buffer *eb, u64 bytenr,
2254                                 int level, u64 owner, struct node_refs *nrefs)
2255 {
2256         struct btrfs_key key;
2257         struct btrfs_root *extent_root = root->fs_info->extent_root;
2258         struct btrfs_path path;
2259         struct btrfs_extent_item *ei;
2260         struct btrfs_extent_inline_ref *iref;
2261         struct extent_buffer *leaf;
2262         unsigned long end;
2263         unsigned long ptr;
2264         int slot;
2265         int skinny_level;
2266         int root_level = btrfs_header_level(root->node);
2267         int type;
2268         u32 nodesize = root->fs_info->nodesize;
2269         u32 item_size;
2270         u64 offset;
2271         int found_ref = 0;
2272         int err = 0;
2273         int ret;
2274         int strict = 1;
2275         int parent = 0;
2276
2277         btrfs_init_path(&path);
2278         key.objectid = bytenr;
2279         if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
2280                 key.type = BTRFS_METADATA_ITEM_KEY;
2281         else
2282                 key.type = BTRFS_EXTENT_ITEM_KEY;
2283         key.offset = (u64)-1;
2284
2285         /* Search for the backref in extent tree */
2286         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2287         if (ret < 0) {
2288                 err |= BACKREF_MISSING;
2289                 goto out;
2290         }
2291         ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
2292         if (ret) {
2293                 err |= BACKREF_MISSING;
2294                 goto out;
2295         }
2296
2297         leaf = path.nodes[0];
2298         slot = path.slots[0];
2299         btrfs_item_key_to_cpu(leaf, &key, slot);
2300
2301         ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
2302
2303         if (key.type == BTRFS_METADATA_ITEM_KEY) {
2304                 skinny_level = (int)key.offset;
2305                 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2306         } else {
2307                 struct btrfs_tree_block_info *info;
2308
2309                 info = (struct btrfs_tree_block_info *)(ei + 1);
2310                 skinny_level = btrfs_tree_block_level(leaf, info);
2311                 iref = (struct btrfs_extent_inline_ref *)(info + 1);
2312         }
2313
2314
2315         if (eb) {
2316                 u64 header_gen;
2317                 u64 extent_gen;
2318
2319                 /*
2320                  * Due to the feature of shared tree blocks, if the upper node
2321                  * is a fs root or shared node, the extent of checked node may
2322                  * not be updated until the next CoW.
2323                  */
2324                 if (nrefs)
2325                         strict = should_check_extent_strictly(root, nrefs,
2326                                         level);
2327                 if (!(btrfs_extent_flags(leaf, ei) &
2328                       BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
2329                         error(
2330                 "extent[%llu %u] backref type mismatch, missing bit: %llx",
2331                                 key.objectid, nodesize,
2332                                 BTRFS_EXTENT_FLAG_TREE_BLOCK);
2333                         err = BACKREF_MISMATCH;
2334                 }
2335                 header_gen = btrfs_header_generation(eb);
2336                 extent_gen = btrfs_extent_generation(leaf, ei);
2337                 if (header_gen != extent_gen) {
2338                         error(
2339         "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
2340                                 key.objectid, nodesize, header_gen,
2341                                 extent_gen);
2342                         err = BACKREF_MISMATCH;
2343                 }
2344                 if (level != skinny_level) {
2345                         error(
2346                         "extent[%llu %u] level mismatch, wanted: %u, have: %u",
2347                                 key.objectid, nodesize, level, skinny_level);
2348                         err = BACKREF_MISMATCH;
2349                 }
2350                 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
2351                         error(
2352                         "extent[%llu %u] is referred by other roots than %llu",
2353                                 key.objectid, nodesize, root->objectid);
2354                         err = BACKREF_MISMATCH;
2355                 }
2356         }
2357
2358         /*
2359          * Iterate the extent/metadata item to find the exact backref
2360          */
2361         item_size = btrfs_item_size_nr(leaf, slot);
2362         ptr = (unsigned long)iref;
2363         end = (unsigned long)ei + item_size;
2364
2365         while (ptr < end) {
2366                 iref = (struct btrfs_extent_inline_ref *)ptr;
2367                 type = btrfs_extent_inline_ref_type(leaf, iref);
2368                 offset = btrfs_extent_inline_ref_offset(leaf, iref);
2369
2370                 ret = check_extent_inline_ref(leaf, &key, iref);
2371                 if (ret) {
2372                         err |= ret;
2373                         break;
2374                 }
2375                 if (type == BTRFS_TREE_BLOCK_REF_KEY) {
2376                         if (offset == root->objectid)
2377                                 found_ref = 1;
2378                         if (!strict && owner == offset)
2379                                 found_ref = 1;
2380                 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
2381                         /*
2382                          * Backref of tree reloc root points to itself, no need
2383                          * to check backref any more.
2384                          *
2385                          * This may be an error of loop backref, but extent tree
2386                          * checker should have already handled it.
2387                          * Here we only need to avoid infinite iteration.
2388                          */
2389                         if (offset == bytenr) {
2390                                 found_ref = 1;
2391                         } else {
2392                                 /*
2393                                  * Check if the backref points to valid
2394                                  * referencer
2395                                  */
2396                                 found_ref = !check_tree_block_ref(root, NULL,
2397                                                 offset, level + 1, owner, NULL);
2398                         }
2399                 }
2400
2401                 if (found_ref)
2402                         break;
2403                 ptr += btrfs_extent_inline_ref_size(type);
2404         }
2405
2406         /*
2407          * Inlined extent item doesn't have what we need, check
2408          * TREE_BLOCK_REF_KEY
2409          */
2410         if (!found_ref) {
2411                 btrfs_release_path(&path);
2412                 key.objectid = bytenr;
2413                 key.type = BTRFS_TREE_BLOCK_REF_KEY;
2414                 key.offset = root->objectid;
2415
2416                 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2417                 if (!ret)
2418                         found_ref = 1;
2419         }
2420         /*
2421          * Finally check SHARED BLOCK REF, any found will be good
2422          * Here we're not doing comprehensive extent backref checking,
2423          * only need to ensure there is some extent referring to this
2424          * tree block.
2425          */
2426         if (!found_ref) {
2427                 btrfs_release_path(&path);
2428                 key.objectid = bytenr;
2429                 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
2430                 key.offset = (u64)-1;
2431
2432                 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2433                 if (ret < 0) {
2434                         err |= BACKREF_MISSING;
2435                         goto out;
2436                 }
2437                 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
2438                 if (ret) {
2439                         err |= BACKREF_MISSING;
2440                         goto out;
2441                 }
2442                 found_ref = 1;
2443         }
2444         if (!found_ref)
2445                 err |= BACKREF_MISSING;
2446 out:
2447         btrfs_release_path(&path);
2448         if (nrefs && strict &&
2449             level < root_level && nrefs->full_backref[level + 1])
2450                 parent = nrefs->bytenr[level + 1];
2451         if (eb && (err & BACKREF_MISSING))
2452                 error(
2453         "extent[%llu %u] backref lost (owner: %llu, level: %u) %s %llu",
2454                       bytenr, nodesize, owner, level,
2455                       parent ? "parent" : "root",
2456                       parent ? parent : root->objectid);
2457         return err;
2458 }
2459
2460 /*
2461  * If @err contains BACKREF_MISSING then add extent of the
2462  * file_extent_data_item.
2463  *
2464  * Returns error bits after reapir.
2465  */
2466 static int repair_extent_data_item(struct btrfs_trans_handle *trans,
2467                                    struct btrfs_root *root,
2468                                    struct btrfs_path *pathp,
2469                                    struct node_refs *nrefs,
2470                                    int err)
2471 {
2472         struct btrfs_file_extent_item *fi;
2473         struct btrfs_key fi_key;
2474         struct btrfs_key key;
2475         struct btrfs_extent_item *ei;
2476         struct btrfs_path path;
2477         struct btrfs_root *extent_root = root->fs_info->extent_root;
2478         struct extent_buffer *eb;
2479         u64 size;
2480         u64 disk_bytenr;
2481         u64 num_bytes;
2482         u64 parent;
2483         u64 offset;
2484         u64 extent_offset;
2485         u64 file_offset;
2486         int generation;
2487         int slot;
2488         int ret = 0;
2489
2490         eb = pathp->nodes[0];
2491         slot = pathp->slots[0];
2492         btrfs_item_key_to_cpu(eb, &fi_key, slot);
2493         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
2494
2495         if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
2496             btrfs_file_extent_disk_bytenr(eb, fi) == 0)
2497                 return err;
2498
2499         file_offset = fi_key.offset;
2500         generation = btrfs_file_extent_generation(eb, fi);
2501         disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
2502         num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
2503         extent_offset = btrfs_file_extent_offset(eb, fi);
2504         offset = file_offset - extent_offset;
2505
2506         /* now repair only adds backref */
2507         if ((err & BACKREF_MISSING) == 0)
2508                 return err;
2509
2510         /* search extent item */
2511         key.objectid = disk_bytenr;
2512         key.type = BTRFS_EXTENT_ITEM_KEY;
2513         key.offset = num_bytes;
2514
2515         btrfs_init_path(&path);
2516         ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
2517         if (ret < 0) {
2518                 ret = -EIO;
2519                 goto out;
2520         }
2521
2522         /* insert an extent item */
2523         if (ret > 0) {
2524                 key.objectid = disk_bytenr;
2525                 key.type = BTRFS_EXTENT_ITEM_KEY;
2526                 key.offset = num_bytes;
2527                 size = sizeof(*ei);
2528
2529                 btrfs_release_path(&path);
2530                 ret = btrfs_insert_empty_item(trans, extent_root, &path, &key,
2531                                               size);
2532                 if (ret)
2533                         goto out;
2534                 eb = path.nodes[0];
2535                 ei = btrfs_item_ptr(eb, path.slots[0], struct btrfs_extent_item);
2536
2537                 btrfs_set_extent_refs(eb, ei, 0);
2538                 btrfs_set_extent_generation(eb, ei, generation);
2539                 btrfs_set_extent_flags(eb, ei, BTRFS_EXTENT_FLAG_DATA);
2540
2541                 btrfs_mark_buffer_dirty(eb);
2542                 ret = btrfs_update_block_group(extent_root, disk_bytenr,
2543                                                num_bytes, 1, 0);
2544                 btrfs_release_path(&path);
2545         }
2546
2547         if (nrefs->full_backref[0])
2548                 parent = btrfs_header_bytenr(eb);
2549         else
2550                 parent = 0;
2551
2552         ret = btrfs_inc_extent_ref(trans, root, disk_bytenr, num_bytes, parent,
2553                                    root->objectid,
2554                    parent ? BTRFS_FIRST_FREE_OBJECTID : fi_key.objectid,
2555                                    offset);
2556         if (ret) {
2557                 error(
2558                 "failed to increase extent data backref[%llu %llu] root %llu",
2559                       disk_bytenr, num_bytes, root->objectid);
2560                 goto out;
2561         } else {
2562                 printf("Add one extent data backref [%llu %llu]\n",
2563                        disk_bytenr, num_bytes);
2564         }
2565
2566         err &= ~BACKREF_MISSING;
2567 out:
2568         if (ret)
2569                 error("can't repair root %llu extent data item[%llu %llu]",
2570                       root->objectid, disk_bytenr, num_bytes);
2571         return err;
2572 }
2573
2574 /*
2575  * Check EXTENT_DATA item, mainly for its dbackref in extent tree
2576  *
2577  * Return >0 any error found and output error message
2578  * Return 0 for no error found
2579  */
2580 static int check_extent_data_item(struct btrfs_root *root,
2581                                   struct btrfs_path *pathp,
2582                                   struct node_refs *nrefs,  int account_bytes)
2583 {
2584         struct btrfs_file_extent_item *fi;
2585         struct extent_buffer *eb = pathp->nodes[0];
2586         struct btrfs_path path;
2587         struct btrfs_root *extent_root = root->fs_info->extent_root;
2588         struct btrfs_key fi_key;
2589         struct btrfs_key dbref_key;
2590         struct extent_buffer *leaf;
2591         struct btrfs_extent_item *ei;
2592         struct btrfs_extent_inline_ref *iref;
2593         struct btrfs_extent_data_ref *dref;
2594         u64 owner;
2595         u64 disk_bytenr;
2596         u64 disk_num_bytes;
2597         u64 extent_num_bytes;
2598         u64 extent_flags;
2599         u64 offset;
2600         u32 item_size;
2601         unsigned long end;
2602         unsigned long ptr;
2603         int type;
2604         int found_dbackref = 0;
2605         int slot = pathp->slots[0];
2606         int err = 0;
2607         int ret;
2608         int strict;
2609
2610         btrfs_item_key_to_cpu(eb, &fi_key, slot);
2611         fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
2612
2613         /* Nothing to check for hole and inline data extents */
2614         if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
2615             btrfs_file_extent_disk_bytenr(eb, fi) == 0)
2616                 return 0;
2617
2618         disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
2619         disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
2620         extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
2621         offset = btrfs_file_extent_offset(eb, fi);
2622
2623         /* Check unaligned disk_num_bytes and num_bytes */
2624         if (!IS_ALIGNED(disk_num_bytes, root->fs_info->sectorsize)) {
2625                 error(
2626 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
2627                         fi_key.objectid, fi_key.offset, disk_num_bytes,
2628                         root->fs_info->sectorsize);
2629                 err |= BYTES_UNALIGNED;
2630         } else if (account_bytes) {
2631                 data_bytes_allocated += disk_num_bytes;
2632         }
2633         if (!IS_ALIGNED(extent_num_bytes, root->fs_info->sectorsize)) {
2634                 error(
2635 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
2636                         fi_key.objectid, fi_key.offset, extent_num_bytes,
2637                         root->fs_info->sectorsize);
2638                 err |= BYTES_UNALIGNED;
2639         } else if (account_bytes) {
2640                 data_bytes_referenced += extent_num_bytes;
2641         }
2642         owner = btrfs_header_owner(eb);
2643
2644         /* Check the extent item of the file extent in extent tree */
2645         btrfs_init_path(&path);
2646         dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
2647         dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
2648         dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
2649
2650         ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
2651         if (ret)
2652                 goto out;
2653
2654         leaf = path.nodes[0];
2655         slot = path.slots[0];
2656         ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
2657
2658         extent_flags = btrfs_extent_flags(leaf, ei);
2659
2660         if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
2661                 error(
2662 "file extent[%llu %llu] root %llu owner %llu backref type mismatch, wanted bit: %llx",
2663                         fi_key.objectid, fi_key.offset, root->objectid, owner,
2664                         BTRFS_EXTENT_FLAG_DATA);
2665                 err |= BACKREF_MISMATCH;
2666         }
2667
2668         /* Check data backref inside that extent item */
2669         item_size = btrfs_item_size_nr(leaf, path.slots[0]);
2670         iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2671         ptr = (unsigned long)iref;
2672         end = (unsigned long)ei + item_size;
2673         strict = should_check_extent_strictly(root, nrefs, -1);
2674
2675         while (ptr < end) {
2676                 u64 ref_root;
2677                 u64 ref_objectid;
2678                 u64 ref_offset;
2679                 bool match = false;
2680
2681                 iref = (struct btrfs_extent_inline_ref *)ptr;
2682                 type = btrfs_extent_inline_ref_type(leaf, iref);
2683                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
2684
2685                 ret = check_extent_inline_ref(leaf, &dbref_key, iref);
2686                 if (ret) {
2687                         err |= ret;
2688                         break;
2689                 }
2690                 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
2691                         ref_root = btrfs_extent_data_ref_root(leaf, dref);
2692                         ref_objectid = btrfs_extent_data_ref_objectid(leaf,
2693                                                                       dref);
2694                         ref_offset = btrfs_extent_data_ref_offset(leaf, dref);
2695
2696                         if (ref_objectid == fi_key.objectid &&
2697                             ref_offset == fi_key.offset - offset)
2698                                 match = true;
2699                         if (ref_root == root->objectid && match)
2700                                 found_dbackref = 1;
2701                         else if (!strict && owner == ref_root && match)
2702                                 found_dbackref = 1;
2703                 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
2704                         found_dbackref = !check_tree_block_ref(root, NULL,
2705                                 btrfs_extent_inline_ref_offset(leaf, iref),
2706                                 0, owner, NULL);
2707                 }
2708
2709                 if (found_dbackref)
2710                         break;
2711                 ptr += btrfs_extent_inline_ref_size(type);
2712         }
2713
2714         if (!found_dbackref) {
2715                 btrfs_release_path(&path);
2716
2717                 /* Didn't find inlined data backref, try EXTENT_DATA_REF_KEY */
2718                 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
2719                 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
2720                 dbref_key.offset = hash_extent_data_ref(owner, fi_key.objectid,
2721                                                         fi_key.offset - offset);
2722
2723                 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
2724                                         &dbref_key, &path, 0, 0);
2725                 if (!ret) {
2726                         found_dbackref = 1;
2727                         goto out;
2728                 }
2729
2730                 btrfs_release_path(&path);
2731
2732                 /*
2733                  * Neither inlined nor EXTENT_DATA_REF found, try
2734                  * SHARED_DATA_REF as last chance.
2735                  */
2736                 dbref_key.objectid = disk_bytenr;
2737                 dbref_key.type = BTRFS_SHARED_DATA_REF_KEY;
2738                 dbref_key.offset = eb->start;
2739
2740                 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
2741                                         &dbref_key, &path, 0, 0);
2742                 if (!ret) {
2743                         found_dbackref = 1;
2744                         goto out;
2745                 }
2746         }
2747
2748 out:
2749         if (!found_dbackref)
2750                 err |= BACKREF_MISSING;
2751         btrfs_release_path(&path);
2752         if (err & BACKREF_MISSING) {
2753                 error(
2754                 "file extent[%llu %llu] root %llu owner %llu backref lost",
2755                         fi_key.objectid, fi_key.offset, root->objectid, owner);
2756         }
2757         return err;
2758 }
2759
2760 /*
2761  * Check a block group item with its referener (chunk) and its used space
2762  * with extent/metadata item
2763  */
2764 static int check_block_group_item(struct btrfs_fs_info *fs_info,
2765                                   struct extent_buffer *eb, int slot)
2766 {
2767         struct btrfs_root *extent_root = fs_info->extent_root;
2768         struct btrfs_root *chunk_root = fs_info->chunk_root;
2769         struct btrfs_block_group_item *bi;
2770         struct btrfs_block_group_item bg_item;
2771         struct btrfs_path path;
2772         struct btrfs_key bg_key;
2773         struct btrfs_key chunk_key;
2774         struct btrfs_key extent_key;
2775         struct btrfs_chunk *chunk;
2776         struct extent_buffer *leaf;
2777         struct btrfs_extent_item *ei;
2778         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
2779         u64 flags;
2780         u64 bg_flags;
2781         u64 used;
2782         u64 total = 0;
2783         int ret;
2784         int err = 0;
2785
2786         btrfs_item_key_to_cpu(eb, &bg_key, slot);
2787         bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
2788         read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
2789         used = btrfs_block_group_used(&bg_item);
2790         bg_flags = btrfs_block_group_flags(&bg_item);
2791
2792         chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
2793         chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
2794         chunk_key.offset = bg_key.objectid;
2795
2796         btrfs_init_path(&path);
2797         /* Search for the referencer chunk */
2798         ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
2799         if (ret) {
2800                 error(
2801                 "block group[%llu %llu] did not find the related chunk item",
2802                         bg_key.objectid, bg_key.offset);
2803                 err |= REFERENCER_MISSING;
2804         } else {
2805                 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
2806                                         struct btrfs_chunk);
2807                 if (btrfs_chunk_length(path.nodes[0], chunk) !=
2808                                                 bg_key.offset) {
2809                         error(
2810         "block group[%llu %llu] related chunk item length does not match",
2811                                 bg_key.objectid, bg_key.offset);
2812                         err |= REFERENCER_MISMATCH;
2813                 }
2814         }
2815         btrfs_release_path(&path);
2816
2817         /* Search from the block group bytenr */
2818         extent_key.objectid = bg_key.objectid;
2819         extent_key.type = 0;
2820         extent_key.offset = 0;
2821
2822         btrfs_init_path(&path);
2823         ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
2824         if (ret < 0)
2825                 goto out;
2826
2827         /* Iterate extent tree to account used space */
2828         while (1) {
2829                 leaf = path.nodes[0];
2830
2831                 /* Search slot can point to the last item beyond leaf nritems */
2832                 if (path.slots[0] >= btrfs_header_nritems(leaf))
2833                         goto next;
2834
2835                 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
2836                 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
2837                         break;
2838
2839                 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
2840                     extent_key.type != BTRFS_EXTENT_ITEM_KEY)
2841                         goto next;
2842                 if (extent_key.objectid < bg_key.objectid)
2843                         goto next;
2844
2845                 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
2846                         total += nodesize;
2847                 else
2848                         total += extent_key.offset;
2849
2850                 ei = btrfs_item_ptr(leaf, path.slots[0],
2851                                     struct btrfs_extent_item);
2852                 flags = btrfs_extent_flags(leaf, ei);
2853                 if (flags & BTRFS_EXTENT_FLAG_DATA) {
2854                         if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
2855                                 error(
2856                         "bad extent[%llu, %llu) type mismatch with chunk",
2857                                       extent_key.objectid,
2858                                       extent_key.objectid + extent_key.offset);
2859                                 err |= CHUNK_TYPE_MISMATCH;
2860                         }
2861                 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
2862                         if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
2863                                     BTRFS_BLOCK_GROUP_METADATA))) {
2864                                 error(
2865                         "bad extent[%llu, %llu) type mismatch with chunk",
2866                                         extent_key.objectid,
2867                                         extent_key.objectid + nodesize);
2868                                 err |= CHUNK_TYPE_MISMATCH;
2869                         }
2870                 }
2871 next:
2872                 ret = btrfs_next_item(extent_root, &path);
2873                 if (ret)
2874                         break;
2875         }
2876
2877 out:
2878         btrfs_release_path(&path);
2879
2880         if (total != used) {
2881                 error(
2882                 "block group[%llu %llu] used %llu but extent items used %llu",
2883                         bg_key.objectid, bg_key.offset, used, total);
2884                 err |= BG_ACCOUNTING_ERROR;
2885         }
2886         return err;
2887 }
2888
2889 /*
2890  * Get real tree block level for the case like shared block
2891  * Return >= 0 as tree level
2892  * Return <0 for error
2893  */
2894 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
2895 {
2896         struct extent_buffer *eb;
2897         struct btrfs_path path;
2898         struct btrfs_key key;
2899         struct btrfs_extent_item *ei;
2900         u64 flags;
2901         u64 transid;
2902         u8 backref_level;
2903         u8 header_level;
2904         int ret;
2905
2906         /* Search extent tree for extent generation and level */
2907         key.objectid = bytenr;
2908         key.type = BTRFS_METADATA_ITEM_KEY;
2909         key.offset = (u64)-1;
2910
2911         btrfs_init_path(&path);
2912         ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
2913         if (ret < 0)
2914                 goto release_out;
2915         ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
2916         if (ret < 0)
2917                 goto release_out;
2918         if (ret > 0) {
2919                 ret = -ENOENT;
2920                 goto release_out;
2921         }
2922
2923         btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
2924         ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
2925                             struct btrfs_extent_item);
2926         flags = btrfs_extent_flags(path.nodes[0], ei);
2927         if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
2928                 ret = -ENOENT;
2929                 goto release_out;
2930         }
2931
2932         /* Get transid for later read_tree_block() check */
2933         transid = btrfs_extent_generation(path.nodes[0], ei);
2934
2935         /* Get backref level as one source */
2936         if (key.type == BTRFS_METADATA_ITEM_KEY) {
2937                 backref_level = key.offset;
2938         } else {
2939                 struct btrfs_tree_block_info *info;
2940
2941                 info = (struct btrfs_tree_block_info *)(ei + 1);
2942                 backref_level = btrfs_tree_block_level(path.nodes[0], info);
2943         }
2944         btrfs_release_path(&path);
2945
2946         /* Get level from tree block as an alternative source */
2947         eb = read_tree_block(fs_info, bytenr, transid);
2948         if (!extent_buffer_uptodate(eb)) {
2949                 free_extent_buffer(eb);
2950                 return -EIO;
2951         }
2952         header_level = btrfs_header_level(eb);
2953         free_extent_buffer(eb);
2954
2955         if (header_level != backref_level)
2956                 return -EIO;
2957         return header_level;
2958
2959 release_out:
2960         btrfs_release_path(&path);
2961         return ret;
2962 }
2963
2964 /*
2965  * Check if a tree block backref is valid (points to a valid tree block)
2966  * if level == -1, level will be resolved
2967  * Return >0 for any error found and print error message
2968  */
2969 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
2970                                     u64 bytenr, int level)
2971 {
2972         struct btrfs_root *root;
2973         struct btrfs_key key;
2974         struct btrfs_path path;
2975         struct extent_buffer *eb;
2976         struct extent_buffer *node;
2977         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
2978         int err = 0;
2979         int ret;
2980
2981         /* Query level for level == -1 special case */
2982         if (level == -1)
2983                 level = query_tree_block_level(fs_info, bytenr);
2984         if (level < 0) {
2985                 err |= REFERENCER_MISSING;
2986                 goto out;
2987         }
2988
2989         key.objectid = root_id;
2990         key.type = BTRFS_ROOT_ITEM_KEY;
2991         key.offset = (u64)-1;
2992
2993         root = btrfs_read_fs_root(fs_info, &key);
2994         if (IS_ERR(root)) {
2995                 err |= REFERENCER_MISSING;
2996                 goto out;
2997         }
2998
2999         /* Read out the tree block to get item/node key */
3000         eb = read_tree_block(fs_info, bytenr, 0);
3001         if (!extent_buffer_uptodate(eb)) {
3002                 err |= REFERENCER_MISSING;
3003                 free_extent_buffer(eb);
3004                 goto out;
3005         }
3006
3007         /* Empty tree, no need to check key */
3008         if (!btrfs_header_nritems(eb) && !level) {
3009                 free_extent_buffer(eb);
3010                 goto out;
3011         }
3012
3013         if (level)
3014                 btrfs_node_key_to_cpu(eb, &key, 0);
3015         else
3016                 btrfs_item_key_to_cpu(eb, &key, 0);
3017
3018         free_extent_buffer(eb);
3019
3020         btrfs_init_path(&path);
3021         path.lowest_level = level;
3022         /* Search with the first key, to ensure we can reach it */
3023         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3024         if (ret < 0) {
3025                 err |= REFERENCER_MISSING;
3026                 goto release_out;
3027         }
3028
3029         node = path.nodes[level];
3030         if (btrfs_header_bytenr(node) != bytenr) {
3031                 error(
3032         "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
3033                         bytenr, nodesize, bytenr,
3034                         btrfs_header_bytenr(node));
3035                 err |= REFERENCER_MISMATCH;
3036         }
3037         if (btrfs_header_level(node) != level) {
3038                 error(
3039         "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
3040                         bytenr, nodesize, level,
3041                         btrfs_header_level(node));
3042                 err |= REFERENCER_MISMATCH;
3043         }
3044
3045 release_out:
3046         btrfs_release_path(&path);
3047 out:
3048         if (err & REFERENCER_MISSING) {
3049                 if (level < 0)
3050                         error("extent [%llu %d] lost referencer (owner: %llu)",
3051                                 bytenr, nodesize, root_id);
3052                 else
3053                         error(
3054                 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
3055                                 bytenr, nodesize, root_id, level);
3056         }
3057
3058         return err;
3059 }
3060
3061 /*
3062  * Check if tree block @eb is tree reloc root.
3063  * Return 0 if it's not or any problem happens
3064  * Return 1 if it's a tree reloc root
3065  */
3066 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
3067                                  struct extent_buffer *eb)
3068 {
3069         struct btrfs_root *tree_reloc_root;
3070         struct btrfs_key key;
3071         u64 bytenr = btrfs_header_bytenr(eb);
3072         u64 owner = btrfs_header_owner(eb);
3073         int ret = 0;
3074
3075         key.objectid = BTRFS_TREE_RELOC_OBJECTID;
3076         key.offset = owner;
3077         key.type = BTRFS_ROOT_ITEM_KEY;
3078
3079         tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
3080         if (IS_ERR(tree_reloc_root))
3081                 return 0;
3082
3083         if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
3084                 ret = 1;
3085         btrfs_free_fs_root(tree_reloc_root);
3086         return ret;
3087 }
3088
3089 /*
3090  * Check referencer for shared block backref
3091  * If level == -1, this function will resolve the level.
3092  */
3093 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
3094                                      u64 parent, u64 bytenr, int level)
3095 {
3096         struct extent_buffer *eb;
3097         u32 nr;
3098         int found_parent = 0;
3099         int i;
3100
3101         eb = read_tree_block(fs_info, parent, 0);
3102         if (!extent_buffer_uptodate(eb))
3103                 goto out;
3104
3105         if (level == -1)
3106                 level = query_tree_block_level(fs_info, bytenr);
3107         if (level < 0)
3108                 goto out;
3109
3110         /* It's possible it's a tree reloc root */
3111         if (parent == bytenr) {
3112                 if (is_tree_reloc_root(fs_info, eb))
3113                         found_parent = 1;
3114                 goto out;
3115         }
3116
3117         if (level + 1 != btrfs_header_level(eb))
3118                 goto out;
3119
3120         nr = btrfs_header_nritems(eb);
3121         for (i = 0; i < nr; i++) {
3122                 if (bytenr == btrfs_node_blockptr(eb, i)) {
3123                         found_parent = 1;
3124                         break;
3125                 }
3126         }
3127 out:
3128         free_extent_buffer(eb);
3129         if (!found_parent) {
3130                 error(
3131         "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
3132                         bytenr, fs_info->nodesize, parent, level);
3133                 return REFERENCER_MISSING;
3134         }
3135         return 0;
3136 }
3137
3138 /*
3139  * Check referencer for normal (inlined) data ref
3140  * If len == 0, it will be resolved by searching in extent tree
3141  */
3142 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
3143                                      u64 root_id, u64 objectid, u64 offset,
3144                                      u64 bytenr, u64 len, u32 count)
3145 {
3146         struct btrfs_root *root;
3147         struct btrfs_root *extent_root = fs_info->extent_root;
3148         struct btrfs_key key;
3149         struct btrfs_path path;
3150         struct extent_buffer *leaf;
3151         struct btrfs_file_extent_item *fi;
3152         u32 found_count = 0;
3153         int slot;
3154         int ret = 0;
3155
3156         if (!len) {
3157                 key.objectid = bytenr;
3158                 key.type = BTRFS_EXTENT_ITEM_KEY;
3159                 key.offset = (u64)-1;
3160
3161                 btrfs_init_path(&path);
3162                 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
3163                 if (ret < 0)
3164                         goto out;
3165                 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
3166                 if (ret)
3167                         goto out;
3168                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
3169                 if (key.objectid != bytenr ||
3170                     key.type != BTRFS_EXTENT_ITEM_KEY)
3171                         goto out;
3172                 len = key.offset;
3173                 btrfs_release_path(&path);
3174         }
3175         key.objectid = root_id;
3176         key.type = BTRFS_ROOT_ITEM_KEY;
3177         key.offset = (u64)-1;
3178         btrfs_init_path(&path);
3179
3180         root = btrfs_read_fs_root(fs_info, &key);
3181         if (IS_ERR(root))
3182                 goto out;
3183
3184         key.objectid = objectid;
3185         key.type = BTRFS_EXTENT_DATA_KEY;
3186         /*
3187          * It can be nasty as data backref offset is
3188          * file offset - file extent offset, which is smaller or
3189          * equal to original backref offset.  The only special case is
3190          * overflow.  So we need to special check and do further search.
3191          */
3192         key.offset = offset & (1ULL << 63) ? 0 : offset;
3193
3194         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3195         if (ret < 0)
3196                 goto out;
3197
3198         /*
3199          * Search afterwards to get correct one
3200          * NOTE: As we must do a comprehensive check on the data backref to
3201          * make sure the dref count also matches, we must iterate all file
3202          * extents for that inode.
3203          */
3204         while (1) {
3205                 leaf = path.nodes[0];
3206                 slot = path.slots[0];
3207
3208                 if (slot >= btrfs_header_nritems(leaf) ||
3209                     btrfs_header_owner(leaf) != root_id)
3210                         goto next;
3211                 btrfs_item_key_to_cpu(leaf, &key, slot);
3212                 if (key.objectid != objectid ||
3213                     key.type != BTRFS_EXTENT_DATA_KEY)
3214                         break;
3215                 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
3216                 /*
3217                  * Except normal disk bytenr and disk num bytes, we still
3218                  * need to do extra check on dbackref offset as
3219                  * dbackref offset = file_offset - file_extent_offset
3220                  *
3221                  * Also, we must check the leaf owner.
3222                  * In case of shared tree blocks (snapshots) we can inherit
3223                  * leaves from source snapshot.
3224                  * In that case, reference from source snapshot should not
3225                  * count.
3226                  */
3227                 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
3228                     btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
3229                     (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
3230                     offset && btrfs_header_owner(leaf) == root_id)
3231                         found_count++;
3232
3233 next:
3234                 ret = btrfs_next_item(root, &path);
3235                 if (ret)
3236                         break;
3237         }
3238 out:
3239         btrfs_release_path(&path);
3240         if (found_count != count) {
3241                 error(
3242 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
3243                         bytenr, len, root_id, objectid, offset, count,
3244                         found_count);
3245                 return REFERENCER_MISSING;
3246         }
3247         return 0;
3248 }
3249
3250 /*
3251  * Check if the referencer of a shared data backref exists
3252  */
3253 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
3254                                      u64 parent, u64 bytenr)
3255 {
3256         struct extent_buffer *eb;
3257         struct btrfs_key key;
3258         struct btrfs_file_extent_item *fi;
3259         u32 nr;
3260         int found_parent = 0;
3261         int i;
3262
3263         eb = read_tree_block(fs_info, parent, 0);
3264         if (!extent_buffer_uptodate(eb))
3265                 goto out;
3266
3267         nr = btrfs_header_nritems(eb);
3268         for (i = 0; i < nr; i++) {
3269                 btrfs_item_key_to_cpu(eb, &key, i);
3270                 if (key.type != BTRFS_EXTENT_DATA_KEY)
3271                         continue;
3272
3273                 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
3274                 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
3275                         continue;
3276
3277                 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
3278                         found_parent = 1;
3279                         break;
3280                 }
3281         }
3282
3283 out:
3284         free_extent_buffer(eb);
3285         if (!found_parent) {
3286                 error("shared extent %llu referencer lost (parent: %llu)",
3287                         bytenr, parent);
3288                 return REFERENCER_MISSING;
3289         }
3290         return 0;
3291 }
3292
3293 /*
3294  * Only delete backref if REFERENCER_MISSING now
3295  *
3296  * Returns <0   the extent was deleted
3297  * Returns >0   the backref was deleted but extent still exists, returned value
3298  *               means error after repair
3299  * Returns  0   nothing happened
3300  */
3301 static int repair_extent_item(struct btrfs_trans_handle *trans,
3302                       struct btrfs_root *root, struct btrfs_path *path,
3303                       u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid,
3304                       u64 owner, u64 offset, int err)
3305 {
3306         struct btrfs_key old_key;
3307         int freed = 0;
3308         int ret;
3309
3310         btrfs_item_key_to_cpu(path->nodes[0], &old_key, path->slots[0]);
3311
3312         if (err & (REFERENCER_MISSING | REFERENCER_MISMATCH)) {
3313                 /* delete the backref */
3314                 ret = btrfs_free_extent(trans, root->fs_info->fs_root, bytenr,
3315                           num_bytes, parent, root_objectid, owner, offset);
3316                 if (!ret) {
3317                         freed = 1;
3318                         err &= ~REFERENCER_MISSING;
3319                         printf("Delete backref in extent [%llu %llu]\n",
3320                                bytenr, num_bytes);
3321                 } else {
3322                         error("fail to delete backref in extent [%llu %llu]",
3323                                bytenr, num_bytes);
3324                 }
3325         }
3326
3327         /* btrfs_free_extent may delete the extent */
3328         btrfs_release_path(path);
3329         ret = btrfs_search_slot(NULL, root, &old_key, path, 0, 0);
3330
3331         if (ret)
3332                 ret = -ENOENT;
3333         else if (freed)
3334                 ret = err;
3335         return ret;
3336 }
3337
3338 /*
3339  * This function will check a given extent item, including its backref and
3340  * itself (like crossing stripe boundary and type)
3341  *
3342  * Since we don't use extent_record anymore, introduce new error bit
3343  */
3344 static int check_extent_item(struct btrfs_trans_handle *trans,
3345                              struct btrfs_fs_info *fs_info,
3346                              struct btrfs_path *path)
3347 {
3348         struct btrfs_extent_item *ei;
3349         struct btrfs_extent_inline_ref *iref;
3350         struct btrfs_extent_data_ref *dref;
3351         struct extent_buffer *eb = path->nodes[0];
3352         unsigned long end;
3353         unsigned long ptr;
3354         int slot = path->slots[0];
3355         int type;
3356         u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
3357         u32 item_size = btrfs_item_size_nr(eb, slot);
3358         u64 flags;
3359         u64 offset;
3360         u64 parent;
3361         u64 num_bytes;
3362         u64 root_objectid;
3363         u64 owner;
3364         u64 owner_offset;
3365         int metadata = 0;
3366         int level;
3367         struct btrfs_key key;
3368         int ret;
3369         int err = 0;
3370
3371         btrfs_item_key_to_cpu(eb, &key, slot);
3372         if (key.type == BTRFS_EXTENT_ITEM_KEY) {
3373                 bytes_used += key.offset;
3374                 num_bytes = key.offset;
3375         } else {
3376                 bytes_used += nodesize;
3377                 num_bytes = nodesize;
3378         }
3379
3380         if (item_size < sizeof(*ei)) {
3381                 /*
3382                  * COMPAT_EXTENT_TREE_V0 case, but it's already a super
3383                  * old thing when on disk format is still un-determined.
3384                  * No need to care about it anymore
3385                  */
3386                 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
3387                 return -ENOTTY;
3388         }
3389
3390         ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
3391         flags = btrfs_extent_flags(eb, ei);
3392
3393         if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
3394                 metadata = 1;
3395         if (metadata && check_crossing_stripes(global_info, key.objectid,
3396                                                eb->len)) {
3397                 error("bad metadata [%llu, %llu) crossing stripe boundary",
3398                       key.objectid, key.objectid + nodesize);
3399                 err |= CROSSING_STRIPE_BOUNDARY;
3400         }
3401
3402         ptr = (unsigned long)(ei + 1);
3403
3404         if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
3405                 /* Old EXTENT_ITEM metadata */
3406                 struct btrfs_tree_block_info *info;
3407
3408                 info = (struct btrfs_tree_block_info *)ptr;
3409                 level = btrfs_tree_block_level(eb, info);
3410                 ptr += sizeof(struct btrfs_tree_block_info);
3411         } else {
3412                 /* New METADATA_ITEM */
3413                 level = key.offset;
3414         }
3415         end = (unsigned long)ei + item_size;
3416
3417 next:
3418         /* Reached extent item end normally */
3419         if (ptr == end)
3420                 goto out;
3421
3422         /* Beyond extent item end, wrong item size */
3423         if (ptr > end) {
3424                 err |= ITEM_SIZE_MISMATCH;
3425                 error("extent item at bytenr %llu slot %d has wrong size",
3426                         eb->start, slot);
3427                 goto out;
3428         }
3429
3430         parent = 0;
3431         root_objectid = 0;
3432         owner = 0;
3433         owner_offset = 0;
3434         /* Now check every backref in this extent item */
3435         iref = (struct btrfs_extent_inline_ref *)ptr;
3436         type = btrfs_extent_inline_ref_type(eb, iref);
3437         offset = btrfs_extent_inline_ref_offset(eb, iref);
3438         switch (type) {
3439         case BTRFS_TREE_BLOCK_REF_KEY:
3440                 root_objectid = offset;
3441                 owner = level;
3442                 ret = check_tree_block_backref(fs_info, offset, key.objectid,
3443                                                level);
3444                 err |= ret;
3445                 break;
3446         case BTRFS_SHARED_BLOCK_REF_KEY:
3447                 parent = offset;
3448                 ret = check_shared_block_backref(fs_info, offset, key.objectid,
3449                                                  level);
3450                 err |= ret;
3451                 break;
3452         case BTRFS_EXTENT_DATA_REF_KEY:
3453                 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
3454                 root_objectid = btrfs_extent_data_ref_root(eb, dref);
3455                 owner = btrfs_extent_data_ref_objectid(eb, dref);
3456                 owner_offset = btrfs_extent_data_ref_offset(eb, dref);
3457                 ret = check_extent_data_backref(fs_info, root_objectid, owner,
3458                                         owner_offset, key.objectid, key.offset,
3459                                         btrfs_extent_data_ref_count(eb, dref));
3460                 err |= ret;
3461                 break;
3462         case BTRFS_SHARED_DATA_REF_KEY:
3463                 parent = offset;
3464                 ret = check_shared_data_backref(fs_info, offset, key.objectid);
3465                 err |= ret;
3466                 break;
3467         default:
3468                 error("extent[%llu %d %llu] has unknown ref type: %d",
3469                         key.objectid, key.type, key.offset, type);
3470                 ret = UNKNOWN_TYPE;
3471                 err |= ret;
3472                 goto out;
3473         }
3474
3475         if (err && repair) {
3476                 ret = repair_extent_item(trans, fs_info->extent_root, path,
3477                          key.objectid, num_bytes, parent, root_objectid,
3478                          owner, owner_offset, ret);
3479                 if (ret < 0)
3480                         goto out;
3481                 if (ret) {
3482                         goto next;
3483                         err = ret;
3484                 }
3485         }
3486
3487         ptr += btrfs_extent_inline_ref_size(type);
3488         goto next;
3489
3490 out:
3491         return err;
3492 }
3493
3494 /*
3495  * Check if a dev extent item is referred correctly by its chunk
3496  */
3497 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
3498                                  struct extent_buffer *eb, int slot)
3499 {
3500         struct btrfs_root *chunk_root = fs_info->chunk_root;
3501         struct btrfs_dev_extent *ptr;
3502         struct btrfs_path path;
3503         struct btrfs_key chunk_key;
3504         struct btrfs_key devext_key;
3505         struct btrfs_chunk *chunk;
3506         struct extent_buffer *l;
3507         int num_stripes;
3508         u64 length;
3509         int i;
3510         int found_chunk = 0;
3511         int ret;
3512
3513         btrfs_item_key_to_cpu(eb, &devext_key, slot);
3514         ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
3515         length = btrfs_dev_extent_length(eb, ptr);
3516
3517         chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
3518         chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
3519         chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
3520
3521         btrfs_init_path(&path);
3522         ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
3523         if (ret)
3524                 goto out;
3525
3526         l = path.nodes[0];
3527         chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
3528         ret = btrfs_check_chunk_valid(fs_info, l, chunk, path.slots[0],
3529                                       chunk_key.offset);
3530         if (ret < 0)
3531                 goto out;
3532
3533         if (btrfs_stripe_length(fs_info, l, chunk) != length)
3534                 goto out;
3535
3536         num_stripes = btrfs_chunk_num_stripes(l, chunk);
3537         for (i = 0; i < num_stripes; i++) {
3538                 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
3539                 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
3540
3541                 if (devid == devext_key.objectid &&
3542                     offset == devext_key.offset) {
3543                         found_chunk = 1;
3544                         break;
3545                 }
3546         }
3547 out:
3548         btrfs_release_path(&path);
3549         if (!found_chunk) {
3550                 error(
3551                 "device extent[%llu, %llu, %llu] did not find the related chunk",
3552                         devext_key.objectid, devext_key.offset, length);
3553                 return REFERENCER_MISSING;
3554         }
3555         return 0;
3556 }
3557
3558 /*
3559  * Check if the used space is correct with the dev item
3560  */
3561 static int check_dev_item(struct btrfs_fs_info *fs_info,
3562                           struct extent_buffer *eb, int slot)
3563 {
3564         struct btrfs_root *dev_root = fs_info->dev_root;
3565         struct btrfs_dev_item *dev_item;
3566         struct btrfs_path path;
3567         struct btrfs_key key;
3568         struct btrfs_dev_extent *ptr;
3569         u64 total_bytes;
3570         u64 dev_id;
3571         u64 used;
3572         u64 total = 0;
3573         int ret;
3574
3575         dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
3576         dev_id = btrfs_device_id(eb, dev_item);
3577         used = btrfs_device_bytes_used(eb, dev_item);
3578         total_bytes = btrfs_device_total_bytes(eb, dev_item);
3579
3580         key.objectid = dev_id;
3581         key.type = BTRFS_DEV_EXTENT_KEY;
3582         key.offset = 0;
3583
3584         btrfs_init_path(&path);
3585         ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
3586         if (ret < 0) {
3587                 btrfs_item_key_to_cpu(eb, &key, slot);
3588                 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
3589                         key.objectid, key.type, key.offset);
3590                 btrfs_release_path(&path);
3591                 return REFERENCER_MISSING;
3592         }
3593
3594         /* Iterate dev_extents to calculate the used space of a device */
3595         while (1) {
3596                 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
3597                         goto next;
3598
3599                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
3600                 if (key.objectid > dev_id)
3601                         break;
3602                 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
3603                         goto next;
3604
3605                 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
3606                                      struct btrfs_dev_extent);
3607                 total += btrfs_dev_extent_length(path.nodes[0], ptr);
3608 next:
3609                 ret = btrfs_next_item(dev_root, &path);
3610                 if (ret)
3611                         break;
3612         }
3613         btrfs_release_path(&path);
3614
3615         if (used != total) {
3616                 btrfs_item_key_to_cpu(eb, &key, slot);
3617                 error(
3618 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
3619                         total, used, BTRFS_ROOT_TREE_OBJECTID,
3620                         BTRFS_DEV_EXTENT_KEY, dev_id);
3621                 return ACCOUNTING_MISMATCH;
3622         }
3623         check_dev_size_alignment(dev_id, total_bytes, fs_info->sectorsize);
3624
3625         return 0;
3626 }
3627
3628 /*
3629  * Check a chunk item.
3630  * Including checking all referred dev_extents and block group
3631  */
3632 static int check_chunk_item(struct btrfs_fs_info *fs_info,
3633                             struct extent_buffer *eb, int slot)
3634 {
3635         struct btrfs_root *extent_root = fs_info->extent_root;
3636         struct btrfs_root *dev_root = fs_info->dev_root;
3637         struct btrfs_path path;
3638         struct btrfs_key chunk_key;
3639         struct btrfs_key bg_key;
3640         struct btrfs_key devext_key;
3641         struct btrfs_chunk *chunk;
3642         struct extent_buffer *leaf;
3643         struct btrfs_block_group_item *bi;
3644         struct btrfs_block_group_item bg_item;
3645         struct btrfs_dev_extent *ptr;
3646         u64 length;
3647         u64 chunk_end;
3648         u64 stripe_len;
3649         u64 type;
3650         int num_stripes;
3651         u64 offset;
3652         u64 objectid;
3653         int i;
3654         int ret;
3655         int err = 0;
3656
3657         btrfs_item_key_to_cpu(eb, &chunk_key, slot);
3658         chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
3659         length = btrfs_chunk_length(eb, chunk);
3660         chunk_end = chunk_key.offset + length;
3661         ret = btrfs_check_chunk_valid(fs_info, eb, chunk, slot,
3662                                       chunk_key.offset);
3663         if (ret < 0) {
3664                 error("chunk[%llu %llu) is invalid", chunk_key.offset,
3665                         chunk_end);
3666                 err |= BYTES_UNALIGNED | UNKNOWN_TYPE;
3667                 goto out;
3668         }
3669         type = btrfs_chunk_type(eb, chunk);
3670
3671         bg_key.objectid = chunk_key.offset;
3672         bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
3673         bg_key.offset = length;
3674
3675         btrfs_init_path(&path);
3676         ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
3677         if (ret) {
3678                 error(
3679                 "chunk[%llu %llu) did not find the related block group item",
3680                         chunk_key.offset, chunk_end);
3681                 err |= REFERENCER_MISSING;
3682         } else{
3683                 leaf = path.nodes[0];
3684                 bi = btrfs_item_ptr(leaf, path.slots[0],
3685                                     struct btrfs_block_group_item);
3686                 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
3687                                    sizeof(bg_item));
3688                 if (btrfs_block_group_flags(&bg_item) != type) {
3689                         error(
3690 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
3691                                 chunk_key.offset, chunk_end, type,
3692                                 btrfs_block_group_flags(&bg_item));
3693                         err |= REFERENCER_MISSING;
3694                 }
3695         }
3696
3697         num_stripes = btrfs_chunk_num_stripes(eb, chunk);
3698         stripe_len = btrfs_stripe_length(fs_info, eb, chunk);
3699         for (i = 0; i < num_stripes; i++) {
3700                 btrfs_release_path(&path);
3701                 btrfs_init_path(&path);
3702                 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
3703                 devext_key.type = BTRFS_DEV_EXTENT_KEY;
3704                 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
3705
3706                 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
3707                                         0, 0);
3708                 if (ret)
3709                         goto not_match_dev;
3710
3711                 leaf = path.nodes[0];
3712                 ptr = btrfs_item_ptr(leaf, path.slots[0],
3713                                      struct btrfs_dev_extent);
3714                 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
3715                 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
3716                 if (objectid != chunk_key.objectid ||
3717                     offset != chunk_key.offset ||
3718                     btrfs_dev_extent_length(leaf, ptr) != stripe_len)
3719                         goto not_match_dev;
3720                 continue;
3721 not_match_dev:
3722                 err |= BACKREF_MISSING;
3723                 error(
3724                 "chunk[%llu %llu) stripe %d did not find the related dev extent",
3725                         chunk_key.objectid, chunk_end, i);
3726                 continue;
3727         }
3728         btrfs_release_path(&path);
3729 out:
3730         return err;
3731 }
3732
3733 /*
3734  * Add block group item to the extent tree if @err contains REFERENCER_MISSING.
3735  * FIXME: We still need to repair error of dev_item.
3736  *
3737  * Returns error after repair.
3738  */
3739 static int repair_chunk_item(struct btrfs_trans_handle *trans,
3740                              struct btrfs_root *chunk_root,
3741                              struct btrfs_path *path, int err)
3742 {
3743         struct btrfs_chunk *chunk;
3744         struct btrfs_key chunk_key;
3745         struct extent_buffer *eb = path->nodes[0];
3746         u64 length;
3747         int slot = path->slots[0];
3748         u64 type;
3749         int ret = 0;
3750
3751         btrfs_item_key_to_cpu(eb, &chunk_key, slot);
3752         if (chunk_key.type != BTRFS_CHUNK_ITEM_KEY)
3753                 return err;
3754         chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
3755         type = btrfs_chunk_type(path->nodes[0], chunk);
3756         length = btrfs_chunk_length(eb, chunk);
3757
3758         if (err & REFERENCER_MISSING) {
3759                 ret = btrfs_make_block_group(trans, chunk_root->fs_info, 0,
3760                                              type, chunk_key.offset, length);
3761                 if (ret) {
3762                         error("fail to add block group item[%llu %llu]",
3763                               chunk_key.offset, length);
3764                         goto out;
3765                 } else {
3766                         err &= ~REFERENCER_MISSING;
3767                         printf("Added block group item[%llu %llu]\n",
3768                                chunk_key.offset, length);
3769                 }
3770         }
3771
3772 out:
3773         return err;
3774 }
3775
3776 static int delete_extent_tree_item(struct btrfs_trans_handle *trans,
3777                                    struct btrfs_root *root,
3778                                    struct btrfs_path *path)
3779 {
3780         struct btrfs_key key;
3781         int ret = 0;
3782
3783         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
3784         btrfs_release_path(path);
3785         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
3786         if (ret) {
3787                 ret = -ENOENT;
3788                 goto out;
3789         }
3790
3791         ret = btrfs_del_item(trans, root, path);
3792         if (ret)
3793                 goto out;
3794
3795         if (path->slots[0] == 0)
3796                 btrfs_prev_leaf(root, path);
3797         else
3798                 path->slots[0]--;
3799 out:
3800         if (ret)
3801                 error("failed to delete root %llu item[%llu, %u, %llu]",
3802                       root->objectid, key.objectid, key.type, key.offset);
3803         else
3804                 printf("Deleted root %llu item[%llu, %u, %llu]\n",
3805                        root->objectid, key.objectid, key.type, key.offset);
3806         return ret;
3807 }
3808
3809 /*
3810  * Main entry function to check known items and update related accounting info
3811  */
3812 static int check_leaf_items(struct btrfs_trans_handle *trans,
3813                             struct btrfs_root *root, struct btrfs_path *path,
3814                             struct node_refs *nrefs, int account_bytes)
3815 {
3816         struct btrfs_fs_info *fs_info = root->fs_info;
3817         struct btrfs_key key;
3818         struct extent_buffer *eb;
3819         int slot;
3820         int type;
3821         struct btrfs_extent_data_ref *dref;
3822         int ret = 0;
3823         int err = 0;
3824
3825 again:
3826         eb = path->nodes[0];
3827         slot = path->slots[0];
3828         if (slot >= btrfs_header_nritems(eb)) {
3829                 if (slot == 0) {
3830                         error("empty leaf [%llu %u] root %llu", eb->start,
3831                                 root->fs_info->nodesize, root->objectid);
3832                         err |= EIO;
3833                 }
3834                 goto out;
3835         }
3836
3837         btrfs_item_key_to_cpu(eb, &key, slot);
3838         type = key.type;
3839
3840         switch (type) {
3841         case BTRFS_EXTENT_DATA_KEY:
3842                 ret = check_extent_data_item(root, path, nrefs, account_bytes);
3843                 if (repair && ret)
3844                         ret = repair_extent_data_item(trans, root, path, nrefs,
3845                                                       ret);
3846                 err |= ret;
3847                 break;
3848         case BTRFS_BLOCK_GROUP_ITEM_KEY:
3849                 ret = check_block_group_item(fs_info, eb, slot);
3850                 if (repair &&
3851                     ret & REFERENCER_MISSING)
3852                         ret = delete_extent_tree_item(trans, root, path);
3853                 err |= ret;
3854                 break;
3855         case BTRFS_DEV_ITEM_KEY:
3856                 ret = check_dev_item(fs_info, eb, slot);
3857                 err |= ret;
3858                 break;
3859         case BTRFS_CHUNK_ITEM_KEY:
3860                 ret = check_chunk_item(fs_info, eb, slot);
3861                 if (repair && ret)
3862                         ret = repair_chunk_item(trans, root, path, ret);
3863                 err |= ret;
3864                 break;
3865         case BTRFS_DEV_EXTENT_KEY:
3866                 ret = check_dev_extent_item(fs_info, eb, slot);
3867                 err |= ret;
3868                 break;
3869         case BTRFS_EXTENT_ITEM_KEY:
3870         case BTRFS_METADATA_ITEM_KEY:
3871                 ret = check_extent_item(trans, fs_info, path);
3872                 err |= ret;
3873                 break;
3874         case BTRFS_EXTENT_CSUM_KEY:
3875                 total_csum_bytes += btrfs_item_size_nr(eb, slot);
3876                 err |= ret;
3877                 break;
3878         case BTRFS_TREE_BLOCK_REF_KEY:
3879                 ret = check_tree_block_backref(fs_info, key.offset,
3880                                                key.objectid, -1);
3881                 if (repair &&
3882                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
3883                         ret = delete_extent_tree_item(trans, root, path);
3884                 err |= ret;
3885                 break;
3886         case BTRFS_EXTENT_DATA_REF_KEY:
3887                 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
3888                 ret = check_extent_data_backref(fs_info,
3889                                 btrfs_extent_data_ref_root(eb, dref),
3890                                 btrfs_extent_data_ref_objectid(eb, dref),
3891                                 btrfs_extent_data_ref_offset(eb, dref),
3892                                 key.objectid, 0,
3893                                 btrfs_extent_data_ref_count(eb, dref));
3894                 if (repair &&
3895                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
3896                         ret = delete_extent_tree_item(trans, root, path);
3897                 err |= ret;
3898                 break;
3899         case BTRFS_SHARED_BLOCK_REF_KEY:
3900                 ret = check_shared_block_backref(fs_info, key.offset,
3901                                                  key.objectid, -1);
3902                 if (repair &&
3903                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
3904                         ret = delete_extent_tree_item(trans, root, path);
3905                 err |= ret;
3906                 break;
3907         case BTRFS_SHARED_DATA_REF_KEY:
3908                 ret = check_shared_data_backref(fs_info, key.offset,
3909                                                 key.objectid);
3910                 if (repair &&
3911                     ret & (REFERENCER_MISMATCH | REFERENCER_MISSING))
3912                         ret = delete_extent_tree_item(trans, root, path);
3913                 err |= ret;
3914                 break;
3915         default:
3916                 break;
3917         }
3918
3919         ++path->slots[0];
3920         goto again;
3921 out:
3922         return err;
3923 }
3924
3925 /*
3926  * @trans      just for lowmem repair mode
3927  * @check all  if not 0 then check all tree block backrefs and items
3928  *             0 then just check relationship of items in fs tree(s)
3929  *
3930  * Returns >0  Found error, should continue
3931  * Returns <0  Fatal error, must exit the whole check
3932  * Returns 0   No errors found
3933  */
3934 static int walk_down_tree(struct btrfs_trans_handle *trans,
3935                           struct btrfs_root *root, struct btrfs_path *path,
3936                           int *level, struct node_refs *nrefs, int ext_ref,
3937                           int check_all)
3938 {
3939         enum btrfs_tree_block_status status;
3940         u64 bytenr;
3941         u64 ptr_gen;
3942         struct btrfs_fs_info *fs_info = root->fs_info;
3943         struct extent_buffer *next;
3944         struct extent_buffer *cur;
3945         int ret;
3946         int err = 0;
3947         int check;
3948         int account_file_data = 0;
3949
3950         WARN_ON(*level < 0);
3951         WARN_ON(*level >= BTRFS_MAX_LEVEL);
3952
3953         ret = update_nodes_refs(root, btrfs_header_bytenr(path->nodes[*level]),
3954                                 path->nodes[*level], nrefs, *level, check_all);
3955         if (ret < 0)
3956                 return ret;
3957
3958         while (*level >= 0) {
3959                 WARN_ON(*level < 0);
3960                 WARN_ON(*level >= BTRFS_MAX_LEVEL);
3961                 cur = path->nodes[*level];
3962                 bytenr = btrfs_header_bytenr(cur);
3963                 check = nrefs->need_check[*level];
3964
3965                 if (btrfs_header_level(cur) != *level)
3966                         WARN_ON(1);
3967                /*
3968                 * Update bytes accounting and check tree block ref
3969                 * NOTE: Doing accounting and check before checking nritems
3970                 * is necessary because of empty node/leaf.
3971                 */
3972                 if ((check_all && !nrefs->checked[*level]) ||
3973                     (!check_all && nrefs->need_check[*level])) {
3974                         ret = check_tree_block_ref(root, cur,
3975                            btrfs_header_bytenr(cur), btrfs_header_level(cur),
3976                            btrfs_header_owner(cur), nrefs);
3977
3978                         if (repair && ret)
3979                                 ret = repair_tree_block_ref(trans, root,
3980                                     path->nodes[*level], nrefs, *level, ret);
3981                         err |= ret;
3982
3983                         if (check_all && nrefs->need_check[*level] &&
3984                                 nrefs->refs[*level]) {
3985                                 account_bytes(root, path, *level);
3986                                 account_file_data = 1;
3987                         }
3988                         nrefs->checked[*level] = 1;
3989                 }
3990
3991                 if (path->slots[*level] >= btrfs_header_nritems(cur))
3992                         break;
3993
3994                 /* Don't forgot to check leaf/node validation */
3995                 if (*level == 0) {
3996                         /* skip duplicate check */
3997                         if (check || !check_all) {
3998                                 ret = btrfs_check_leaf(root, NULL, cur);
3999                                 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
4000                                         err |= -EIO;
4001                                         break;
4002                                 }
4003                         }
4004
4005                         ret = 0;
4006                         if (!check_all)
4007                                 ret = process_one_leaf(root, path, nrefs,
4008                                                        level, ext_ref);
4009                         else
4010                                 ret = check_leaf_items(trans, root, path,
4011                                                nrefs, account_file_data);
4012                         err |= ret;
4013                         break;
4014                 }
4015                 if (check || !check_all) {
4016                         ret = btrfs_check_node(root, NULL, cur);
4017                         if (ret != BTRFS_TREE_BLOCK_CLEAN) {
4018                                 err |= -EIO;
4019                                 break;
4020                         }
4021                 }
4022
4023                 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
4024                 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
4025
4026                 ret = update_nodes_refs(root, bytenr, NULL, nrefs, *level - 1,
4027                                         check_all);
4028                 if (ret < 0)
4029                         break;
4030                 /*
4031                  * check all trees in check_chunks_and_extent
4032                  * check shared node once in check_fs_roots
4033                  */
4034                 if (!check_all && !nrefs->need_check[*level - 1]) {
4035                         path->slots[*level]++;
4036                         continue;
4037                 }
4038
4039                 next = btrfs_find_tree_block(fs_info, bytenr, fs_info->nodesize);
4040                 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
4041                         free_extent_buffer(next);
4042                         reada_walk_down(root, cur, path->slots[*level]);
4043                         next = read_tree_block(fs_info, bytenr, ptr_gen);
4044                         if (!extent_buffer_uptodate(next)) {
4045                                 struct btrfs_key node_key;
4046
4047                                 btrfs_node_key_to_cpu(path->nodes[*level],
4048                                                       &node_key,
4049                                                       path->slots[*level]);
4050                                 btrfs_add_corrupt_extent_record(fs_info,
4051                                         &node_key, path->nodes[*level]->start,
4052                                         fs_info->nodesize, *level);
4053                                 err |= -EIO;
4054                                 break;
4055                         }
4056                 }
4057
4058                 ret = check_child_node(cur, path->slots[*level], next);
4059                 err |= ret;
4060                 if (ret < 0)
4061                         break;
4062
4063                 if (btrfs_is_leaf(next))
4064                         status = btrfs_check_leaf(root, NULL, next);
4065                 else
4066                         status = btrfs_check_node(root, NULL, next);
4067                 if (status != BTRFS_TREE_BLOCK_CLEAN) {
4068                         free_extent_buffer(next);
4069                         err |= -EIO;
4070                         break;
4071                 }
4072
4073                 *level = *level - 1;
4074                 free_extent_buffer(path->nodes[*level]);
4075                 path->nodes[*level] = next;
4076                 path->slots[*level] = 0;
4077                 account_file_data = 0;
4078
4079                 update_nodes_refs(root, (u64)-1, next, nrefs, *level, check_all);
4080         }
4081         return err;
4082 }
4083
4084 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
4085                         int *level)
4086 {
4087         int i;
4088         struct extent_buffer *leaf;
4089
4090         for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
4091                 leaf = path->nodes[i];
4092                 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
4093                         path->slots[i]++;
4094                         *level = i;
4095                         return 0;
4096                 }
4097                 free_extent_buffer(path->nodes[*level]);
4098                 path->nodes[*level] = NULL;
4099                 *level = i + 1;
4100         }
4101         return 1;
4102 }
4103
4104 /*
4105  * Insert the missing inode item and inode ref.
4106  *
4107  * Normal INODE_ITEM_MISSING and INODE_REF_MISSING are handled in backref * dir.
4108  * Root dir should be handled specially because root dir is the root of fs.
4109  *
4110  * returns err (>0 or 0) after repair
4111  */
4112 static int repair_fs_first_inode(struct btrfs_root *root, int err)
4113 {
4114         struct btrfs_trans_handle *trans;
4115         struct btrfs_key key;
4116         struct btrfs_path path;
4117         int filetype = BTRFS_FT_DIR;
4118         int ret = 0;
4119
4120         btrfs_init_path(&path);
4121
4122         if (err & INODE_REF_MISSING) {
4123                 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4124                 key.type = BTRFS_INODE_REF_KEY;
4125                 key.offset = BTRFS_FIRST_FREE_OBJECTID;
4126
4127                 trans = btrfs_start_transaction(root, 1);
4128                 if (IS_ERR(trans)) {
4129                         ret = PTR_ERR(trans);
4130                         goto out;
4131                 }
4132
4133                 btrfs_release_path(&path);
4134                 ret = btrfs_search_slot(trans, root, &key, &path, 1, 1);
4135                 if (ret)
4136                         goto trans_fail;
4137
4138                 ret = btrfs_insert_inode_ref(trans, root, "..", 2,
4139                                              BTRFS_FIRST_FREE_OBJECTID,
4140                                              BTRFS_FIRST_FREE_OBJECTID, 0);
4141                 if (ret)
4142                         goto trans_fail;
4143
4144                 printf("Add INODE_REF[%llu %llu] name %s\n",
4145                        BTRFS_FIRST_FREE_OBJECTID, BTRFS_FIRST_FREE_OBJECTID,
4146                        "..");
4147                 err &= ~INODE_REF_MISSING;
4148 trans_fail:
4149                 if (ret)
4150                         error("fail to insert first inode's ref");
4151                 btrfs_commit_transaction(trans, root);
4152         }
4153
4154         if (err & INODE_ITEM_MISSING) {
4155                 ret = repair_inode_item_missing(root,
4156                                         BTRFS_FIRST_FREE_OBJECTID, filetype);
4157                 if (ret)
4158                         goto out;
4159                 err &= ~INODE_ITEM_MISSING;
4160         }
4161 out:
4162         if (ret)
4163                 error("fail to repair first inode");
4164         btrfs_release_path(&path);
4165         return err;
4166 }
4167
4168 /*
4169  * check first root dir's inode_item and inode_ref
4170  *
4171  * returns 0 means no error
4172  * returns >0 means error
4173  * returns <0 means fatal error
4174  */
4175 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
4176 {
4177         struct btrfs_path path;
4178         struct btrfs_key key;
4179         struct btrfs_inode_item *ii;
4180         u64 index;
4181         u32 mode;
4182         int err = 0;
4183         int ret;
4184
4185         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
4186         key.type = BTRFS_INODE_ITEM_KEY;
4187         key.offset = 0;
4188
4189         /* For root being dropped, we don't need to check first inode */
4190         if (btrfs_root_refs(&root->root_item) == 0 &&
4191             btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
4192             BTRFS_FIRST_FREE_OBJECTID)
4193                 return 0;
4194
4195         btrfs_init_path(&path);
4196         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4197         if (ret < 0)
4198                 goto out;
4199         if (ret > 0) {
4200                 ret = 0;
4201                 err |= INODE_ITEM_MISSING;
4202         } else {
4203                 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4204                                     struct btrfs_inode_item);
4205                 mode = btrfs_inode_mode(path.nodes[0], ii);
4206                 if (imode_to_type(mode) != BTRFS_FT_DIR)
4207                         err |= INODE_ITEM_MISMATCH;
4208         }
4209
4210         /* lookup first inode ref */
4211         key.offset = BTRFS_FIRST_FREE_OBJECTID;
4212         key.type = BTRFS_INODE_REF_KEY;
4213         /* special index value */
4214         index = 0;
4215
4216         ret = find_inode_ref(root, &key, "..", strlen(".."), &index, ext_ref);
4217         if (ret < 0)
4218                 goto out;
4219         err |= ret;
4220
4221 out:
4222         btrfs_release_path(&path);
4223
4224         if (err && repair)
4225                 err = repair_fs_first_inode(root, err);
4226
4227         if (err & (INODE_ITEM_MISSING | INODE_ITEM_MISMATCH))
4228                 error("root dir INODE_ITEM is %s",
4229                       err & INODE_ITEM_MISMATCH ? "mismatch" : "missing");
4230         if (err & INODE_REF_MISSING)
4231                 error("root dir INODE_REF is missing");
4232
4233         return ret < 0 ? ret : err;
4234 }
4235
4236 /*
4237  * This function calls walk_down_tree and walk_up_tree to check tree
4238  * blocks and integrity of fs tree items.
4239  *
4240  * @root:         the root of the tree to be checked.
4241  * @ext_ref       feature EXTENDED_IREF is enable or not.
4242  * @account       if NOT 0 means check the tree (including tree)'s treeblocks.
4243  *                otherwise means check fs tree(s) items relationship and
4244  *                @root MUST be a fs tree root.
4245  * Returns 0      represents OK.
4246  * Returns not 0  represents error.
4247  */
4248 static int check_btrfs_root(struct btrfs_trans_handle *trans,
4249                             struct btrfs_root *root, unsigned int ext_ref,
4250                             int check_all)
4251 {
4252         struct btrfs_path path;
4253         struct node_refs nrefs;
4254         struct btrfs_root_item *root_item = &root->root_item;
4255         int ret;
4256         int level;
4257         int err = 0;
4258
4259         memset(&nrefs, 0, sizeof(nrefs));
4260         if (!check_all) {
4261                 /*
4262                  * We need to manually check the first inode item (256)
4263                  * As the following traversal function will only start from
4264                  * the first inode item in the leaf, if inode item (256) is
4265                  * missing we will skip it forever.
4266                  */
4267                 ret = check_fs_first_inode(root, ext_ref);
4268                 if (ret < 0)
4269                         return ret;
4270         }
4271
4272
4273         level = btrfs_header_level(root->node);
4274         btrfs_init_path(&path);
4275
4276         if (btrfs_root_refs(root_item) > 0 ||
4277             btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
4278                 path.nodes[level] = root->node;
4279                 path.slots[level] = 0;
4280                 extent_buffer_get(root->node);
4281         } else {
4282                 struct btrfs_key key;
4283
4284                 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
4285                 level = root_item->drop_level;
4286                 path.lowest_level = level;
4287                 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4288                 if (ret < 0)
4289                         goto out;
4290                 ret = 0;
4291         }
4292
4293         while (1) {
4294                 ret = walk_down_tree(trans, root, &path, &level, &nrefs,
4295                                      ext_ref, check_all);
4296
4297                 err |= !!ret;
4298
4299                 /* if ret is negative, walk shall stop */
4300                 if (ret < 0) {
4301                         ret = err;
4302                         break;
4303                 }
4304
4305                 ret = walk_up_tree(root, &path, &level);
4306                 if (ret != 0) {
4307                         /* Normal exit, reset ret to err */
4308                         ret = err;
4309                         break;
4310                 }
4311         }
4312
4313 out:
4314         btrfs_release_path(&path);
4315         return ret;
4316 }
4317
4318 /*
4319  * Iterate all items in the tree and call check_inode_item() to check.
4320  *
4321  * @root:       the root of the tree to be checked.
4322  * @ext_ref:    the EXTENDED_IREF feature
4323  *
4324  * Return 0 if no error found.
4325  * Return <0 for error.
4326  */
4327 static int check_fs_root(struct btrfs_root *root, unsigned int ext_ref)
4328 {
4329         reset_cached_block_groups(root->fs_info);
4330         return check_btrfs_root(NULL, root, ext_ref, 0);
4331 }
4332
4333 /*
4334  * Find the relative ref for root_ref and root_backref.
4335  *
4336  * @root:       the root of the root tree.
4337  * @ref_key:    the key of the root ref.
4338  *
4339  * Return 0 if no error occurred.
4340  */
4341 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4342                           struct extent_buffer *node, int slot)
4343 {
4344         struct btrfs_path path;
4345         struct btrfs_key key;
4346         struct btrfs_root_ref *ref;
4347         struct btrfs_root_ref *backref;
4348         char ref_name[BTRFS_NAME_LEN] = {0};
4349         char backref_name[BTRFS_NAME_LEN] = {0};
4350         u64 ref_dirid;
4351         u64 ref_seq;
4352         u32 ref_namelen;
4353         u64 backref_dirid;
4354         u64 backref_seq;
4355         u32 backref_namelen;
4356         u32 len;
4357         int ret;
4358         int err = 0;
4359
4360         ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
4361         ref_dirid = btrfs_root_ref_dirid(node, ref);
4362         ref_seq = btrfs_root_ref_sequence(node, ref);
4363         ref_namelen = btrfs_root_ref_name_len(node, ref);
4364
4365         if (ref_namelen <= BTRFS_NAME_LEN) {
4366                 len = ref_namelen;
4367         } else {
4368                 len = BTRFS_NAME_LEN;
4369                 warning("%s[%llu %llu] ref_name too long",
4370                         ref_key->type == BTRFS_ROOT_REF_KEY ?
4371                         "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
4372                         ref_key->offset);
4373         }
4374         read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
4375
4376         /* Find relative root_ref */
4377         key.objectid = ref_key->offset;
4378         key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
4379         key.offset = ref_key->objectid;
4380
4381         btrfs_init_path(&path);
4382         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
4383         if (ret) {
4384                 err |= ROOT_REF_MISSING;
4385                 error("%s[%llu %llu] couldn't find relative ref",
4386                       ref_key->type == BTRFS_ROOT_REF_KEY ?
4387                       "ROOT_REF" : "ROOT_BACKREF",
4388                       ref_key->objectid, ref_key->offset);
4389                 goto out;
4390         }
4391
4392         backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
4393                                  struct btrfs_root_ref);
4394         backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
4395         backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
4396         backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
4397
4398         if (backref_namelen <= BTRFS_NAME_LEN) {
4399                 len = backref_namelen;
4400         } else {
4401                 len = BTRFS_NAME_LEN;
4402                 warning("%s[%llu %llu] ref_name too long",
4403                         key.type == BTRFS_ROOT_REF_KEY ?
4404                         "ROOT_REF" : "ROOT_BACKREF",
4405                         key.objectid, key.offset);
4406         }
4407         read_extent_buffer(path.nodes[0], backref_name,
4408                            (unsigned long)(backref + 1), len);
4409
4410         if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
4411             ref_namelen != backref_namelen ||
4412             strncmp(ref_name, backref_name, len)) {
4413                 err |= ROOT_REF_MISMATCH;
4414                 error("%s[%llu %llu] mismatch relative ref",
4415                       ref_key->type == BTRFS_ROOT_REF_KEY ?
4416                       "ROOT_REF" : "ROOT_BACKREF",
4417                       ref_key->objectid, ref_key->offset);
4418         }
4419 out:
4420         btrfs_release_path(&path);
4421         return err;
4422 }
4423
4424 /*
4425  * Check all fs/file tree in low_memory mode.
4426  *
4427  * 1. for fs tree root item, call check_fs_root()
4428  * 2. for fs tree root ref/backref, call check_root_ref()
4429  *
4430  * Return 0 if no error occurred.
4431  */
4432 int check_fs_roots_lowmem(struct btrfs_fs_info *fs_info)
4433 {
4434         struct btrfs_root *tree_root = fs_info->tree_root;
4435         struct btrfs_root *cur_root = NULL;
4436         struct btrfs_path path;
4437         struct btrfs_key key;
4438         struct extent_buffer *node;
4439         unsigned int ext_ref;
4440         int slot;
4441         int ret;
4442         int err = 0;
4443
4444         ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
4445
4446         btrfs_init_path(&path);
4447         key.objectid = BTRFS_FS_TREE_OBJECTID;
4448         key.offset = 0;
4449         key.type = BTRFS_ROOT_ITEM_KEY;
4450
4451         ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4452         if (ret < 0) {
4453                 err = ret;
4454                 goto out;
4455         } else if (ret > 0) {
4456                 err = -ENOENT;
4457                 goto out;
4458         }
4459
4460         while (1) {
4461                 node = path.nodes[0];
4462                 slot = path.slots[0];
4463                 btrfs_item_key_to_cpu(node, &key, slot);
4464                 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
4465                         goto out;
4466                 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4467                     fs_root_objectid(key.objectid)) {
4468                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4469                                 cur_root = btrfs_read_fs_root_no_cache(fs_info,
4470                                                                        &key);
4471                         } else {
4472                                 key.offset = (u64)-1;
4473                                 cur_root = btrfs_read_fs_root(fs_info, &key);
4474                         }
4475
4476                         if (IS_ERR(cur_root)) {
4477                                 error("Fail to read fs/subvol tree: %lld",
4478                                       key.objectid);
4479                                 err = -EIO;
4480                                 goto next;
4481                         }
4482
4483                         ret = check_fs_root(cur_root, ext_ref);
4484                         err |= ret;
4485
4486                         if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4487                                 btrfs_free_fs_root(cur_root);
4488                 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4489                                 key.type == BTRFS_ROOT_BACKREF_KEY) {
4490                         ret = check_root_ref(tree_root, &key, node, slot);
4491                         err |= ret;
4492                 }
4493 next:
4494                 ret = btrfs_next_item(tree_root, &path);
4495                 if (ret > 0)
4496                         goto out;
4497                 if (ret < 0) {
4498                         err = ret;
4499                         goto out;
4500                 }
4501         }
4502
4503 out:
4504         btrfs_release_path(&path);
4505         return err;
4506 }
4507
4508 /*
4509  * Low memory usage version check_chunks_and_extents.
4510  */
4511 int check_chunks_and_extents_lowmem(struct btrfs_fs_info *fs_info)
4512 {
4513         struct btrfs_trans_handle *trans = NULL;
4514         struct btrfs_path path;
4515         struct btrfs_key old_key;
4516         struct btrfs_key key;
4517         struct btrfs_root *root1;
4518         struct btrfs_root *root;
4519         struct btrfs_root *cur_root;
4520         int err = 0;
4521         int ret;
4522
4523         root = fs_info->fs_root;
4524
4525         if (repair) {
4526                 trans = btrfs_start_transaction(fs_info->extent_root, 1);
4527                 if (IS_ERR(trans)) {
4528                         error("failed to start transaction before check");
4529                         return PTR_ERR(trans);
4530                 }
4531         }
4532
4533         root1 = root->fs_info->chunk_root;
4534         ret = check_btrfs_root(trans, root1, 0, 1);
4535         err |= ret;
4536
4537         root1 = root->fs_info->tree_root;
4538         ret = check_btrfs_root(trans, root1, 0, 1);
4539         err |= ret;
4540
4541         btrfs_init_path(&path);
4542         key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
4543         key.offset = 0;
4544         key.type = BTRFS_ROOT_ITEM_KEY;
4545
4546         ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
4547         if (ret) {
4548                 error("cannot find extent tree in tree_root");
4549                 goto out;
4550         }
4551
4552         while (1) {
4553                 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
4554                 if (key.type != BTRFS_ROOT_ITEM_KEY)
4555                         goto next;
4556                 old_key = key;
4557                 key.offset = (u64)-1;
4558
4559                 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4560                         cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
4561                                         &key);
4562                 else
4563                         cur_root = btrfs_read_fs_root(root->fs_info, &key);
4564                 if (IS_ERR(cur_root) || !cur_root) {
4565                         error("failed to read tree: %lld", key.objectid);
4566                         goto next;
4567                 }
4568
4569                 ret = check_btrfs_root(trans, cur_root, 0, 1);
4570                 err |= ret;
4571
4572                 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4573                         btrfs_free_fs_root(cur_root);
4574
4575                 btrfs_release_path(&path);
4576                 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
4577                                         &old_key, &path, 0, 0);
4578                 if (ret)
4579                         goto out;
4580 next:
4581                 ret = btrfs_next_item(root1, &path);
4582                 if (ret)
4583                         goto out;
4584         }
4585 out:
4586
4587         /* if repair, update block accounting */
4588         if (repair) {
4589                 ret = btrfs_fix_block_accounting(trans, root);
4590                 if (ret)
4591                         err |= ret;
4592                 else
4593                         err &= ~BG_ACCOUNTING_ERROR;
4594         }
4595
4596         if (trans)
4597                 btrfs_commit_transaction(trans, root->fs_info->extent_root);
4598
4599         btrfs_release_path(&path);
4600
4601         return err;
4602 }