disk-io.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include "kerncompat.h"
  26 #include "radix-tree.h"
  27 #include "ctree.h"
  28 #include "disk-io.h"
  29 #include "volumes.h"
  30 #include "transaction.h"
  31 #include "crc32c.h"
  32 #include "utils.h"
  33 #include "print-tree.h"
  34 #include "rbtree-utils.h"
  35
  36 static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
  37 {
  38
  39         struct btrfs_fs_devices *fs_devices;
  40         int ret = 1;
  41
  42         if (buf->start != btrfs_header_bytenr(buf)) {
  43                 printk("Check tree block failed, want=%Lu, have=%Lu\n",
  44                        buf->start, btrfs_header_bytenr(buf));
  45                 return ret;
  46         }
  47
  48         fs_devices = root->fs_info->fs_devices;
  49         while (fs_devices) {
  50                 if (!memcmp_extent_buffer(buf, fs_devices->fsid,
  51                                           btrfs_header_fsid(),
  52                                           BTRFS_FSID_SIZE)) {
  53                         ret = 0;
  54                         break;
  55                 }
  56                 fs_devices = fs_devices->seed;
  57         }
  58         return ret;
  59 }
  60
  61 u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
  62 {
  63         return crc32c(seed, data, len);
  64 }
  65
  66 void btrfs_csum_final(u32 crc, char *result)
  67 {
  68         *(__le32 *)result = ~cpu_to_le32(crc);
  69 }
  70
  71 static int __csum_tree_block_size(struct extent_buffer *buf, u16 csum_size,
  72                                   int verify, int silent)
  73 {
  74         char *result;
  75         u32 len;
  76         u32 crc = ~(u32)0;
  77
  78         result = malloc(csum_size * sizeof(char));
  79         if (!result)
  80                 return 1;
  81
  82         len = buf->len - BTRFS_CSUM_SIZE;
  83         crc = crc32c(crc, buf->data + BTRFS_CSUM_SIZE, len);
  84         btrfs_csum_final(crc, result);
  85
  86         if (verify) {
  87                 if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
  88                         if (!silent)
  89                                 printk("checksum verify failed on %llu found %08X wanted %08X\n",
  90                                        (unsigned long long)buf->start,
  91                                        *((u32 *)result),
  92                                        *((u32*)(char *)buf->data));
  93                         free(result);
  94                         return 1;
  95                 }
  96         } else {
  97                 write_extent_buffer(buf, result, 0, csum_size);
  98         }
  99         free(result);
 100         return 0;
 101 }
 102
 103 int csum_tree_block_size(struct extent_buffer *buf, u16 csum_size, int verify)
 104 {
 105         return __csum_tree_block_size(buf, csum_size, verify, 0);
 106 }
 107
 108 int verify_tree_block_csum_silent(struct extent_buffer *buf, u16 csum_size)
 109 {
 110         return __csum_tree_block_size(buf, csum_size, 1, 1);
 111 }
 112
 113 int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
 114                            int verify)
 115 {
 116         u16 csum_size =
 117                 btrfs_super_csum_size(root->fs_info->super_copy);
 118         return csum_tree_block_size(buf, csum_size, verify);
 119 }
 120
 121 struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
 122                                             u64 bytenr, u32 blocksize)
 123 {
 124         return find_extent_buffer(&root->fs_info->extent_cache,
 125                                   bytenr, blocksize);
 126 }
 127
 128 struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
 129                                                  u64 bytenr, u32 blocksize)
 130 {
 131         return alloc_extent_buffer(&root->fs_info->extent_cache, bytenr,
 132                                    blocksize);
 133 }
 134
 135 void readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
 136                           u64 parent_transid)
 137 {
 138         struct extent_buffer *eb;
 139         u64 length;
 140         struct btrfs_multi_bio *multi = NULL;
 141         struct btrfs_device *device;
 142
 143         eb = btrfs_find_tree_block(root, bytenr, blocksize);
 144         if (!(eb && btrfs_buffer_uptodate(eb, parent_transid)) &&
 145             !btrfs_map_block(&root->fs_info->mapping_tree, READ,
 146                              bytenr, &length, &multi, 0, NULL)) {
 147                 device = multi->stripes[0].dev;
 148                 device->total_ios++;
 149                 blocksize = min(blocksize, (u32)(64 * 1024));
 150                 readahead(device->fd, multi->stripes[0].physical, blocksize);
 151         }
 152
 153         free_extent_buffer(eb);
 154         kfree(multi);
 155 }
 156
 157 static int verify_parent_transid(struct extent_io_tree *io_tree,
 158                                  struct extent_buffer *eb, u64 parent_transid,
 159                                  int ignore)
 160 {
 161         int ret;
 162
 163         if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
 164                 return 0;
 165
 166         if (extent_buffer_uptodate(eb) &&
 167             btrfs_header_generation(eb) == parent_transid) {
 168                 ret = 0;
 169                 goto out;
 170         }
 171         printk("parent transid verify failed on %llu wanted %llu found %llu\n",
 172                (unsigned long long)eb->start,
 173                (unsigned long long)parent_transid,
 174                (unsigned long long)btrfs_header_generation(eb));
 175         if (ignore) {
 176                 eb->flags |= EXTENT_BAD_TRANSID;
 177                 printk("Ignoring transid failure\n");
 178                 return 0;
 179         }
 180
 181         ret = 1;
 182 out:
 183         clear_extent_buffer_uptodate(io_tree, eb);
 184         return ret;
 185
 186 }
 187
 188
 189 int read_whole_eb(struct btrfs_fs_info *info, struct extent_buffer *eb, int mirror)
 190 {
 191         unsigned long offset = 0;
 192         struct btrfs_multi_bio *multi = NULL;
 193         struct btrfs_device *device;
 194         int ret = 0;
 195         u64 read_len;
 196         unsigned long bytes_left = eb->len;
 197
 198         while (bytes_left) {
 199                 read_len = bytes_left;
 200                 device = NULL;
 201
 202                 if (!info->on_restoring &&
 203                     eb->start != BTRFS_SUPER_INFO_OFFSET) {
 204                         ret = btrfs_map_block(&info->mapping_tree, READ,
 205                                               eb->start + offset, &read_len, &multi,
 206                                               mirror, NULL);
 207                         if (ret) {
 208                                 printk("Couldn't map the block %Lu\n", eb->start + offset);
 209                                 kfree(multi);
 210                                 return -EIO;
 211                         }
 212                         device = multi->stripes[0].dev;
 213
 214                         if (device->fd == 0) {
 215                                 kfree(multi);
 216                                 return -EIO;
 217                         }
 218
 219                         eb->fd = device->fd;
 220                         device->total_ios++;
 221                         eb->dev_bytenr = multi->stripes[0].physical;
 222                         kfree(multi);
 223                         multi = NULL;
 224                 } else {
 225                         /* special case for restore metadump */
 226                         list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
 227                                 if (device->devid == 1)
 228                                         break;
 229                         }
 230
 231                         eb->fd = device->fd;
 232                         eb->dev_bytenr = eb->start;
 233                         device->total_ios++;
 234                 }
 235
 236                 if (read_len > bytes_left)
 237                         read_len = bytes_left;
 238
 239                 ret = read_extent_from_disk(eb, offset, read_len);
 240                 if (ret)
 241                         return -EIO;
 242                 offset += read_len;
 243                 bytes_left -= read_len;
 244         }
 245         return 0;
 246 }
 247
 248 struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
 249                                      u32 blocksize, u64 parent_transid)
 250 {
 251         int ret;
 252         struct extent_buffer *eb;
 253         u64 best_transid = 0;
 254         int mirror_num = 0;
 255         int good_mirror = 0;
 256         int num_copies;
 257         int ignore = 0;
 258
 259         eb = btrfs_find_create_tree_block(root, bytenr, blocksize);
 260         if (!eb)
 261                 return ERR_PTR(-ENOMEM);
 262
 263         if (btrfs_buffer_uptodate(eb, parent_transid))
 264                 return eb;
 265
 266         while (1) {
 267                 ret = read_whole_eb(root->fs_info, eb, mirror_num);
 268                 if (ret == 0 && check_tree_block(root, eb) == 0 &&
 269                     csum_tree_block(root, eb, 1) == 0 &&
 270                     verify_parent_transid(eb->tree, eb, parent_transid, ignore)
 271                     == 0) {
 272                         if (eb->flags & EXTENT_BAD_TRANSID &&
 273                             list_empty(&eb->recow)) {
 274                                 list_add_tail(&eb->recow,
 275                                               &root->fs_info->recow_ebs);
 276                                 eb->refs++;
 277                         }
 278                         btrfs_set_buffer_uptodate(eb);
 279                         return eb;
 280                 }
 281                 if (ignore) {
 282                         if (check_tree_block(root, eb))
 283                                 printk("read block failed check_tree_block\n");
 284                         else
 285                                 printk("Csum didn't match\n");
 286                         ret = -EIO;
 287                         break;
 288                 }
 289                 num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
 290                                               eb->start, eb->len);
 291                 if (num_copies == 1) {
 292                         ignore = 1;
 293                         continue;
 294                 }
 295                 if (btrfs_header_generation(eb) > best_transid && mirror_num) {
 296                         best_transid = btrfs_header_generation(eb);
 297                         good_mirror = mirror_num;
 298                 }
 299                 mirror_num++;
 300                 if (mirror_num > num_copies) {
 301                         mirror_num = good_mirror;
 302                         ignore = 1;
 303                         continue;
 304                 }
 305         }
 306         free_extent_buffer(eb);
 307         return ERR_PTR(ret);
 308 }
 309
 310 int write_and_map_eb(struct btrfs_trans_handle *trans,
 311                      struct btrfs_root *root,
 312                      struct extent_buffer *eb)
 313 {
 314         int ret;
 315         int dev_nr;
 316         u64 length;
 317         u64 *raid_map = NULL;
 318         struct btrfs_multi_bio *multi = NULL;
 319
 320         dev_nr = 0;
 321         length = eb->len;
 322         ret = btrfs_map_block(&root->fs_info->mapping_tree, WRITE,
 323                               eb->start, &length, &multi, 0, &raid_map);
 324
 325         if (raid_map) {
 326                 ret = write_raid56_with_parity(root->fs_info, eb, multi,
 327                                                length, raid_map);
 328                 BUG_ON(ret);
 329         } else while (dev_nr < multi->num_stripes) {
 330                 BUG_ON(ret);
 331                 eb->fd = multi->stripes[dev_nr].dev->fd;
 332                 eb->dev_bytenr = multi->stripes[dev_nr].physical;
 333                 multi->stripes[dev_nr].dev->total_ios++;
 334                 dev_nr++;
 335                 ret = write_extent_to_disk(eb);
 336                 BUG_ON(ret);
 337         }
 338         kfree(multi);
 339         return 0;
 340 }
 341
 342 static int write_tree_block(struct btrfs_trans_handle *trans,
 343                      struct btrfs_root *root,
 344                      struct extent_buffer *eb)
 345 {
 346         if (check_tree_block(root, eb))
 347                 BUG();
 348
 349         if (!btrfs_buffer_uptodate(eb, trans->transid))
 350                 BUG();
 351
 352         btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
 353         csum_tree_block(root, eb, 0);
 354
 355         return write_and_map_eb(trans, root, eb);
 356 }
 357
 358 int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
 359                         u32 stripesize, struct btrfs_root *root,
 360                         struct btrfs_fs_info *fs_info, u64 objectid)
 361 {
 362         root->node = NULL;
 363         root->commit_root = NULL;
 364         root->sectorsize = sectorsize;
 365         root->nodesize = nodesize;
 366         root->leafsize = leafsize;
 367         root->stripesize = stripesize;
 368         root->ref_cows = 0;
 369         root->track_dirty = 0;
 370
 371         root->fs_info = fs_info;
 372         root->objectid = objectid;
 373         root->last_trans = 0;
 374         root->highest_inode = 0;
 375         root->last_inode_alloc = 0;
 376
 377         INIT_LIST_HEAD(&root->dirty_list);
 378         INIT_LIST_HEAD(&root->orphan_data_extents);
 379         memset(&root->root_key, 0, sizeof(root->root_key));
 380         memset(&root->root_item, 0, sizeof(root->root_item));
 381         root->root_key.objectid = objectid;
 382         return 0;
 383 }
 384
 385 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 386                                struct btrfs_root *root)
 387 {
 388         int ret;
 389         u64 old_root_bytenr;
 390         struct btrfs_root *tree_root = root->fs_info->tree_root;
 391
 392         btrfs_write_dirty_block_groups(trans, root);
 393         while(1) {
 394                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 395                 if (old_root_bytenr == root->node->start)
 396                         break;
 397                 btrfs_set_root_bytenr(&root->root_item,
 398                                        root->node->start);
 399                 btrfs_set_root_generation(&root->root_item,
 400                                           trans->transid);
 401                 root->root_item.level = btrfs_header_level(root->node);
 402                 ret = btrfs_update_root(trans, tree_root,
 403                                         &root->root_key,
 404                                         &root->root_item);
 405                 BUG_ON(ret);
 406                 btrfs_write_dirty_block_groups(trans, root);
 407         }
 408         return 0;
 409 }
 410
 411 static int commit_tree_roots(struct btrfs_trans_handle *trans,
 412                              struct btrfs_fs_info *fs_info)
 413 {
 414         struct btrfs_root *root;
 415         struct list_head *next;
 416         struct extent_buffer *eb;
 417         int ret;
 418
 419         if (fs_info->readonly)
 420                 return 0;
 421
 422         eb = fs_info->tree_root->node;
 423         extent_buffer_get(eb);
 424         ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
 425         free_extent_buffer(eb);
 426         if (ret)
 427                 return ret;
 428
 429         while(!list_empty(&fs_info->dirty_cowonly_roots)) {
 430                 next = fs_info->dirty_cowonly_roots.next;
 431                 list_del_init(next);
 432                 root = list_entry(next, struct btrfs_root, dirty_list);
 433                 update_cowonly_root(trans, root);
 434                 free_extent_buffer(root->commit_root);
 435                 root->commit_root = NULL;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static int __commit_transaction(struct btrfs_trans_handle *trans,
 442                                 struct btrfs_root *root)
 443 {
 444         u64 start;
 445         u64 end;
 446         struct extent_buffer *eb;
 447         struct extent_io_tree *tree = &root->fs_info->extent_cache;
 448         int ret;
 449
 450         while(1) {
 451                 ret = find_first_extent_bit(tree, 0, &start, &end,
 452                                             EXTENT_DIRTY);
 453                 if (ret)
 454                         break;
 455                 while(start <= end) {
 456                         eb = find_first_extent_buffer(tree, start);
 457                         BUG_ON(!eb || eb->start != start);
 458                         ret = write_tree_block(trans, root, eb);
 459                         BUG_ON(ret);
 460                         start += eb->len;
 461                         clear_extent_buffer_dirty(eb);
 462                         free_extent_buffer(eb);
 463                 }
 464         }
 465         return 0;
 466 }
 467
 468 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 469                              struct btrfs_root *root)
 470 {
 471         u64 transid = trans->transid;
 472         int ret = 0;
 473         struct btrfs_fs_info *fs_info = root->fs_info;
 474
 475         if (root->commit_root == root->node)
 476                 goto commit_tree;
 477         if (root == root->fs_info->tree_root)
 478                 goto commit_tree;
 479
 480         free_extent_buffer(root->commit_root);
 481         root->commit_root = NULL;
 482
 483         btrfs_set_root_bytenr(&root->root_item, root->node->start);
 484         btrfs_set_root_generation(&root->root_item, trans->transid);
 485         root->root_item.level = btrfs_header_level(root->node);
 486         ret = btrfs_update_root(trans, root->fs_info->tree_root,
 487                                 &root->root_key, &root->root_item);
 488         BUG_ON(ret);
 489 commit_tree:
 490         ret = commit_tree_roots(trans, fs_info);
 491         BUG_ON(ret);
 492         ret = __commit_transaction(trans, root);
 493         BUG_ON(ret);
 494         write_ctree_super(trans, root);
 495         btrfs_finish_extent_commit(trans, fs_info->extent_root,
 496                                    &fs_info->pinned_extents);
 497         btrfs_free_transaction(root, trans);
 498         free_extent_buffer(root->commit_root);
 499         root->commit_root = NULL;
 500         fs_info->running_transaction = NULL;
 501         fs_info->last_trans_committed = transid;
 502         return 0;
 503 }
 504
 505 static int find_and_setup_root(struct btrfs_root *tree_root,
 506                                struct btrfs_fs_info *fs_info,
 507                                u64 objectid, struct btrfs_root *root)
 508 {
 509         int ret;
 510         u32 blocksize;
 511         u64 generation;
 512
 513         __setup_root(tree_root->nodesize, tree_root->leafsize,
 514                      tree_root->sectorsize, tree_root->stripesize,
 515                      root, fs_info, objectid);
 516         ret = btrfs_find_last_root(tree_root, objectid,
 517                                    &root->root_item, &root->root_key);
 518         if (ret)
 519                 return ret;
 520
 521         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
 522         generation = btrfs_root_generation(&root->root_item);
 523         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
 524                                      blocksize, generation);
 525         if (!extent_buffer_uptodate(root->node))
 526                 return -EIO;
 527
 528         return 0;
 529 }
 530
 531 static int find_and_setup_log_root(struct btrfs_root *tree_root,
 532                                struct btrfs_fs_info *fs_info,
 533                                struct btrfs_super_block *disk_super)
 534 {
 535         u32 blocksize;
 536         u64 blocknr = btrfs_super_log_root(disk_super);
 537         struct btrfs_root *log_root = malloc(sizeof(struct btrfs_root));
 538
 539         if (!log_root)
 540                 return -ENOMEM;
 541
 542         if (blocknr == 0) {
 543                 free(log_root);
 544                 return 0;
 545         }
 546
 547         blocksize = btrfs_level_size(tree_root,
 548                              btrfs_super_log_root_level(disk_super));
 549
 550         __setup_root(tree_root->nodesize, tree_root->leafsize,
 551                      tree_root->sectorsize, tree_root->stripesize,
 552                      log_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
 553
 554         log_root->node = read_tree_block(tree_root, blocknr,
 555                                      blocksize,
 556                                      btrfs_super_generation(disk_super) + 1);
 557
 558         fs_info->log_root_tree = log_root;
 559
 560         if (!extent_buffer_uptodate(log_root->node)) {
 561                 free_extent_buffer(log_root->node);
 562                 free(log_root);
 563                 fs_info->log_root_tree = NULL;
 564                 return -EIO;
 565         }
 566
 567         return 0;
 568 }
 569
 570 int btrfs_free_fs_root(struct btrfs_root *root)
 571 {
 572         if (root->node)
 573                 free_extent_buffer(root->node);
 574         if (root->commit_root)
 575                 free_extent_buffer(root->commit_root);
 576         kfree(root);
 577         return 0;
 578 }
 579
 580 static void __free_fs_root(struct rb_node *node)
 581 {
 582         struct btrfs_root *root;
 583
 584         root = container_of(node, struct btrfs_root, rb_node);
 585         btrfs_free_fs_root(root);
 586 }
 587
 588 FREE_RB_BASED_TREE(fs_roots, __free_fs_root);
 589
 590 struct btrfs_root *btrfs_read_fs_root_no_cache(struct btrfs_fs_info *fs_info,
 591                                                struct btrfs_key *location)
 592 {
 593         struct btrfs_root *root;
 594         struct btrfs_root *tree_root = fs_info->tree_root;
 595         struct btrfs_path *path;
 596         struct extent_buffer *l;
 597         u64 generation;
 598         u32 blocksize;
 599         int ret = 0;
 600
 601         root = malloc(sizeof(*root));
 602         if (!root)
 603                 return ERR_PTR(-ENOMEM);
 604         memset(root, 0, sizeof(*root));
 605         if (location->offset == (u64)-1) {
 606                 ret = find_and_setup_root(tree_root, fs_info,
 607                                           location->objectid, root);
 608                 if (ret) {
 609                         free(root);
 610                         return ERR_PTR(ret);
 611                 }
 612                 goto insert;
 613         }
 614
 615         __setup_root(tree_root->nodesize, tree_root->leafsize,
 616                      tree_root->sectorsize, tree_root->stripesize,
 617                      root, fs_info, location->objectid);
 618
 619         path = btrfs_alloc_path();
 620         BUG_ON(!path);
 621         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
 622         if (ret != 0) {
 623                 if (ret > 0)
 624                         ret = -ENOENT;
 625                 goto out;
 626         }
 627         l = path->nodes[0];
 628         read_extent_buffer(l, &root->root_item,
 629                btrfs_item_ptr_offset(l, path->slots[0]),
 630                sizeof(root->root_item));
 631         memcpy(&root->root_key, location, sizeof(*location));
 632         ret = 0;
 633 out:
 634         btrfs_free_path(path);
 635         if (ret) {
 636                 free(root);
 637                 return ERR_PTR(ret);
 638         }
 639         generation = btrfs_root_generation(&root->root_item);
 640         blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
 641         root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
 642                                      blocksize, generation);
 643         if (!extent_buffer_uptodate(root->node)) {
 644                 free(root);
 645                 return ERR_PTR(-EIO);
 646         }
 647 insert:
 648         root->ref_cows = 1;
 649         return root;
 650 }
 651
 652 static int btrfs_fs_roots_compare_objectids(struct rb_node *node,
 653                                             void *data)
 654 {
 655         u64 objectid = *((u64 *)data);
 656         struct btrfs_root *root;
 657
 658         root = rb_entry(node, struct btrfs_root, rb_node);
 659         if (objectid > root->objectid)
 660                 return 1;
 661         else if (objectid < root->objectid)
 662                 return -1;
 663         else
 664                 return 0;
 665 }
 666
 667 static int btrfs_fs_roots_compare_roots(struct rb_node *node1,
 668                                         struct rb_node *node2)
 669 {
 670         struct btrfs_root *root;
 671
 672         root = rb_entry(node2, struct btrfs_root, rb_node);
 673         return btrfs_fs_roots_compare_objectids(node1, (void *)&root->objectid);
 674 }
 675
 676 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
 677                                       struct btrfs_key *location)
 678 {
 679         struct btrfs_root *root;
 680         struct rb_node *node;
 681         int ret;
 682         u64 objectid = location->objectid;
 683
 684         if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
 685                 return fs_info->tree_root;
 686         if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
 687                 return fs_info->extent_root;
 688         if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
 689                 return fs_info->chunk_root;
 690         if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
 691                 return fs_info->dev_root;
 692         if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
 693                 return fs_info->csum_root;
 694         if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
 695                 return fs_info->quota_root;
 696
 697         BUG_ON(location->objectid == BTRFS_TREE_RELOC_OBJECTID ||
 698                location->offset != (u64)-1);
 699
 700         node = rb_search(&fs_info->fs_root_tree, (void *)&objectid,
 701                          btrfs_fs_roots_compare_objectids, NULL);
 702         if (node)
 703                 return container_of(node, struct btrfs_root, rb_node);
 704
 705         root = btrfs_read_fs_root_no_cache(fs_info, location);
 706         if (IS_ERR(root))
 707                 return root;
 708
 709         ret = rb_insert(&fs_info->fs_root_tree, &root->rb_node,
 710                         btrfs_fs_roots_compare_roots);
 711         BUG_ON(ret);
 712         return root;
 713 }
 714
 715 void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
 716 {
 717         free(fs_info->tree_root);
 718         free(fs_info->extent_root);
 719         free(fs_info->chunk_root);
 720         free(fs_info->dev_root);
 721         free(fs_info->csum_root);
 722         free(fs_info->quota_root);
 723         free(fs_info->super_copy);
 724         free(fs_info->log_root_tree);
 725         free(fs_info);
 726 }
 727
 728 struct btrfs_fs_info *btrfs_new_fs_info(int writable, u64 sb_bytenr)
 729 {
 730         struct btrfs_fs_info *fs_info;
 731
 732         fs_info = malloc(sizeof(struct btrfs_fs_info));
 733         if (!fs_info)
 734                 return NULL;
 735
 736         memset(fs_info, 0, sizeof(struct btrfs_fs_info));
 737
 738         fs_info->tree_root = malloc(sizeof(struct btrfs_root));
 739         fs_info->extent_root = malloc(sizeof(struct btrfs_root));
 740         fs_info->chunk_root = malloc(sizeof(struct btrfs_root));
 741         fs_info->dev_root = malloc(sizeof(struct btrfs_root));
 742         fs_info->csum_root = malloc(sizeof(struct btrfs_root));
 743         fs_info->quota_root = malloc(sizeof(struct btrfs_root));
 744         fs_info->super_copy = malloc(BTRFS_SUPER_INFO_SIZE);
 745
 746         if (!fs_info->tree_root || !fs_info->extent_root ||
 747             !fs_info->chunk_root || !fs_info->dev_root ||
 748             !fs_info->csum_root || !fs_info->quota_root ||
 749             !fs_info->super_copy)
 750                 goto free_all;
 751
 752         memset(fs_info->super_copy, 0, BTRFS_SUPER_INFO_SIZE);
 753         memset(fs_info->tree_root, 0, sizeof(struct btrfs_root));
 754         memset(fs_info->extent_root, 0, sizeof(struct btrfs_root));
 755         memset(fs_info->chunk_root, 0, sizeof(struct btrfs_root));
 756         memset(fs_info->dev_root, 0, sizeof(struct btrfs_root));
 757         memset(fs_info->csum_root, 0, sizeof(struct btrfs_root));
 758         memset(fs_info->quota_root, 0, sizeof(struct btrfs_root));
 759
 760         extent_io_tree_init(&fs_info->extent_cache);
 761         extent_io_tree_init(&fs_info->free_space_cache);
 762         extent_io_tree_init(&fs_info->block_group_cache);
 763         extent_io_tree_init(&fs_info->pinned_extents);
 764         extent_io_tree_init(&fs_info->pending_del);
 765         extent_io_tree_init(&fs_info->extent_ins);
 766         fs_info->excluded_extents = NULL;
 767
 768         fs_info->fs_root_tree = RB_ROOT;
 769         cache_tree_init(&fs_info->mapping_tree.cache_tree);
 770
 771         mutex_init(&fs_info->fs_mutex);
 772         INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
 773         INIT_LIST_HEAD(&fs_info->space_info);
 774         INIT_LIST_HEAD(&fs_info->recow_ebs);
 775
 776         if (!writable)
 777                 fs_info->readonly = 1;
 778
 779         fs_info->super_bytenr = sb_bytenr;
 780         fs_info->data_alloc_profile = (u64)-1;
 781         fs_info->metadata_alloc_profile = (u64)-1;
 782         fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
 783         return fs_info;
 784 free_all:
 785         btrfs_free_fs_info(fs_info);
 786         return NULL;
 787 }
 788
 789 int btrfs_check_fs_compatibility(struct btrfs_super_block *sb, int writable)
 790 {
 791         u64 features;
 792
 793         features = btrfs_super_incompat_flags(sb) &
 794                    ~BTRFS_FEATURE_INCOMPAT_SUPP;
 795         if (features) {
 796                 printk("couldn't open because of unsupported "
 797                        "option features (%Lx).\n",
 798                        (unsigned long long)features);
 799                 return -ENOTSUP;
 800         }
 801
 802         features = btrfs_super_incompat_flags(sb);
 803         if (!(features & BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF)) {
 804                 features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
 805                 btrfs_set_super_incompat_flags(sb, features);
 806         }
 807
 808         features = btrfs_super_compat_ro_flags(sb) &
 809                 ~BTRFS_FEATURE_COMPAT_RO_SUPP;
 810         if (writable && features) {
 811                 printk("couldn't open RDWR because of unsupported "
 812                        "option features (%Lx).\n",
 813                        (unsigned long long)features);
 814                 return -ENOTSUP;
 815         }
 816         return 0;
 817 }
 818
 819 static int find_best_backup_root(struct btrfs_super_block *super)
 820 {
 821         struct btrfs_root_backup *backup;
 822         u64 orig_gen = btrfs_super_generation(super);
 823         u64 gen = 0;
 824         int best_index = 0;
 825         int i;
 826
 827         for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
 828                 backup = super->super_roots + i;
 829                 if (btrfs_backup_tree_root_gen(backup) != orig_gen &&
 830                     btrfs_backup_tree_root_gen(backup) > gen) {
 831                         best_index = i;
 832                         gen = btrfs_backup_tree_root_gen(backup);
 833                 }
 834         }
 835         return best_index;
 836 }
 837
 838 static int setup_root_or_create_block(struct btrfs_fs_info *fs_info,
 839                                       enum btrfs_open_ctree_flags flags,
 840                                       struct btrfs_root *info_root,
 841                                       u64 objectid, char *str)
 842 {
 843         struct btrfs_super_block *sb = fs_info->super_copy;
 844         struct btrfs_root *root = fs_info->tree_root;
 845         u32 leafsize = btrfs_super_leafsize(sb);
 846         int ret;
 847
 848         ret = find_and_setup_root(root, fs_info, objectid, info_root);
 849         if (ret) {
 850                 printk("Couldn't setup %s tree\n", str);
 851                 if (!(flags & OPEN_CTREE_PARTIAL))
 852                         return -EIO;
 853                 /*
 854                  * Need a blank node here just so we don't screw up in the
 855                  * million of places that assume a root has a valid ->node
 856                  */
 857                 info_root->node =
 858                         btrfs_find_create_tree_block(info_root, 0, leafsize);
 859                 if (!info_root->node)
 860                         return -ENOMEM;
 861                 clear_extent_buffer_uptodate(NULL, info_root->node);
 862         }
 863
 864         return 0;
 865 }
 866
 867 int btrfs_setup_all_roots(struct btrfs_fs_info *fs_info, u64 root_tree_bytenr,
 868                           enum btrfs_open_ctree_flags flags)
 869 {
 870         struct btrfs_super_block *sb = fs_info->super_copy;
 871         struct btrfs_root *root;
 872         struct btrfs_key key;
 873         u32 sectorsize;
 874         u32 nodesize;
 875         u32 leafsize;
 876         u32 stripesize;
 877         u64 generation;
 878         u32 blocksize;
 879         int ret;
 880
 881         nodesize = btrfs_super_nodesize(sb);
 882         leafsize = btrfs_super_leafsize(sb);
 883         sectorsize = btrfs_super_sectorsize(sb);
 884         stripesize = btrfs_super_stripesize(sb);
 885
 886         root = fs_info->tree_root;
 887         __setup_root(nodesize, leafsize, sectorsize, stripesize,
 888                      root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
 889         blocksize = btrfs_level_size(root, btrfs_super_root_level(sb));
 890         generation = btrfs_super_generation(sb);
 891
 892         if (!root_tree_bytenr && !(flags & OPEN_CTREE_BACKUP_ROOT)) {
 893                 root_tree_bytenr = btrfs_super_root(sb);
 894         } else if (flags & OPEN_CTREE_BACKUP_ROOT) {
 895                 struct btrfs_root_backup *backup;
 896                 int index = find_best_backup_root(sb);
 897                 if (index >= BTRFS_NUM_BACKUP_ROOTS) {
 898                         fprintf(stderr, "Invalid backup root number\n");
 899                         return -EIO;
 900                 }
 901                 backup = fs_info->super_copy->super_roots + index;
 902                 root_tree_bytenr = btrfs_backup_tree_root(backup);
 903                 generation = btrfs_backup_tree_root_gen(backup);
 904         }
 905
 906         root->node = read_tree_block(root, root_tree_bytenr, blocksize,
 907                                      generation);
 908         if (!extent_buffer_uptodate(root->node)) {
 909                 fprintf(stderr, "Couldn't read tree root\n");
 910                 return -EIO;
 911         }
 912
 913         ret = setup_root_or_create_block(fs_info, flags, fs_info->extent_root,
 914                                          BTRFS_EXTENT_TREE_OBJECTID, "extent");
 915         if (ret)
 916                 return ret;
 917         fs_info->extent_root->track_dirty = 1;
 918
 919         ret = find_and_setup_root(root, fs_info, BTRFS_DEV_TREE_OBJECTID,
 920                                   fs_info->dev_root);
 921         if (ret) {
 922                 printk("Couldn't setup device tree\n");
 923                 return -EIO;
 924         }
 925         fs_info->dev_root->track_dirty = 1;
 926
 927         ret = setup_root_or_create_block(fs_info, flags, fs_info->csum_root,
 928                                          BTRFS_CSUM_TREE_OBJECTID, "csum");
 929         if (ret)
 930                 return ret;
 931         fs_info->csum_root->track_dirty = 1;
 932
 933         ret = find_and_setup_root(root, fs_info, BTRFS_QUOTA_TREE_OBJECTID,
 934                                   fs_info->quota_root);
 935         if (ret == 0)
 936                 fs_info->quota_enabled = 1;
 937
 938         ret = find_and_setup_log_root(root, fs_info, sb);
 939         if (ret) {
 940                 printk("Couldn't setup log root tree\n");
 941                 if (!(flags & OPEN_CTREE_PARTIAL))
 942                         return -EIO;
 943         }
 944
 945         fs_info->generation = generation;
 946         fs_info->last_trans_committed = generation;
 947         if (extent_buffer_uptodate(fs_info->extent_root->node) &&
 948             !(flags & OPEN_CTREE_NO_BLOCK_GROUPS))
 949                 btrfs_read_block_groups(fs_info->tree_root);
 950
 951         key.objectid = BTRFS_FS_TREE_OBJECTID;
 952         key.type = BTRFS_ROOT_ITEM_KEY;
 953         key.offset = (u64)-1;
 954         fs_info->fs_root = btrfs_read_fs_root(fs_info, &key);
 955
 956         if (IS_ERR(fs_info->fs_root))
 957                 return -EIO;
 958         return 0;
 959 }
 960
 961 void btrfs_release_all_roots(struct btrfs_fs_info *fs_info)
 962 {
 963         if (fs_info->quota_root)
 964                 free_extent_buffer(fs_info->quota_root->node);
 965         if (fs_info->csum_root)
 966                 free_extent_buffer(fs_info->csum_root->node);
 967         if (fs_info->dev_root)
 968                 free_extent_buffer(fs_info->dev_root->node);
 969         if (fs_info->extent_root)
 970                 free_extent_buffer(fs_info->extent_root->node);
 971         if (fs_info->tree_root)
 972                 free_extent_buffer(fs_info->tree_root->node);
 973         if (fs_info->log_root_tree)
 974                 free_extent_buffer(fs_info->log_root_tree->node);
 975         if (fs_info->chunk_root)
 976                 free_extent_buffer(fs_info->chunk_root->node);
 977 }
 978
 979 static void free_map_lookup(struct cache_extent *ce)
 980 {
 981         struct map_lookup *map;
 982
 983         map = container_of(ce, struct map_lookup, ce);
 984         kfree(map);
 985 }
 986
 987 FREE_EXTENT_CACHE_BASED_TREE(mapping_cache, free_map_lookup);
 988
 989 void btrfs_cleanup_all_caches(struct btrfs_fs_info *fs_info)
 990 {
 991         while (!list_empty(&fs_info->recow_ebs)) {
 992                 struct extent_buffer *eb;
 993                 eb = list_first_entry(&fs_info->recow_ebs,
 994                                       struct extent_buffer, recow);
 995                 list_del_init(&eb->recow);
 996                 free_extent_buffer(eb);
 997         }
 998         free_mapping_cache_tree(&fs_info->mapping_tree.cache_tree);
 999         extent_io_tree_cleanup(&fs_info->extent_cache);
1000         extent_io_tree_cleanup(&fs_info->free_space_cache);
1001         extent_io_tree_cleanup(&fs_info->block_group_cache);
1002         extent_io_tree_cleanup(&fs_info->pinned_extents);
1003         extent_io_tree_cleanup(&fs_info->pending_del);
1004         extent_io_tree_cleanup(&fs_info->extent_ins);
1005 }
1006
1007 int btrfs_scan_fs_devices(int fd, const char *path,
1008                           struct btrfs_fs_devices **fs_devices,
1009                           u64 sb_bytenr, int super_recover)
1010 {
1011         u64 total_devs;
1012         u64 dev_size;
1013         off_t seek_ret;
1014         int ret;
1015         if (!sb_bytenr)
1016                 sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
1017
1018         seek_ret = lseek(fd, 0, SEEK_END);
1019         if (seek_ret < 0)
1020                 return -errno;
1021
1022         dev_size = seek_ret;
1023         lseek(fd, 0, SEEK_SET);
1024         if (sb_bytenr > dev_size) {
1025                 fprintf(stderr, "Superblock bytenr is larger than device size\n");
1026                 return -EINVAL;
1027         }
1028
1029         ret = btrfs_scan_one_device(fd, path, fs_devices,
1030                                     &total_devs, sb_bytenr, super_recover);
1031         if (ret) {
1032                 fprintf(stderr, "No valid Btrfs found on %s\n", path);
1033                 return ret;
1034         }
1035
1036         if (total_devs != 1) {
1037                 ret = btrfs_scan_lblkid();
1038                 if (ret)
1039                         return ret;
1040         }
1041         return 0;
1042 }
1043
1044 int btrfs_setup_chunk_tree_and_device_map(struct btrfs_fs_info *fs_info)
1045 {
1046         struct btrfs_super_block *sb = fs_info->super_copy;
1047         u32 sectorsize;
1048         u32 nodesize;
1049         u32 leafsize;
1050         u32 blocksize;
1051         u32 stripesize;
1052         u64 generation;
1053         int ret;
1054
1055         nodesize = btrfs_super_nodesize(sb);
1056         leafsize = btrfs_super_leafsize(sb);
1057         sectorsize = btrfs_super_sectorsize(sb);
1058         stripesize = btrfs_super_stripesize(sb);
1059
1060         __setup_root(nodesize, leafsize, sectorsize, stripesize,
1061                      fs_info->chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
1062
1063         ret = btrfs_read_sys_array(fs_info->chunk_root);
1064         if (ret)
1065                 return ret;
1066
1067         blocksize = btrfs_level_size(fs_info->chunk_root,
1068                                      btrfs_super_chunk_root_level(sb));
1069         generation = btrfs_super_chunk_root_generation(sb);
1070
1071         fs_info->chunk_root->node = read_tree_block(fs_info->chunk_root,
1072                                                     btrfs_super_chunk_root(sb),
1073                                                     blocksize, generation);
1074         if (!extent_buffer_uptodate(fs_info->chunk_root->node)) {
1075                 fprintf(stderr, "Couldn't read chunk root\n");
1076                 return -EIO;
1077         }
1078
1079         if (!(btrfs_super_flags(sb) & BTRFS_SUPER_FLAG_METADUMP)) {
1080                 ret = btrfs_read_chunk_tree(fs_info->chunk_root);
1081                 if (ret) {
1082                         fprintf(stderr, "Couldn't read chunk tree\n");
1083                         return ret;
1084                 }
1085         }
1086         return 0;
1087 }
1088
1089 static struct btrfs_fs_info *__open_ctree_fd(int fp, const char *path,
1090                                              u64 sb_bytenr,
1091                                              u64 root_tree_bytenr,
1092                                              enum btrfs_open_ctree_flags flags)
1093 {
1094         struct btrfs_fs_info *fs_info;
1095         struct btrfs_super_block *disk_super;
1096         struct btrfs_fs_devices *fs_devices = NULL;
1097         struct extent_buffer *eb;
1098         int ret;
1099         int oflags;
1100
1101         if (sb_bytenr == 0)
1102                 sb_bytenr = BTRFS_SUPER_INFO_OFFSET;
1103
1104         /* try to drop all the caches */
1105         if (posix_fadvise(fp, 0, 0, POSIX_FADV_DONTNEED))
1106                 fprintf(stderr, "Warning, could not drop caches\n");
1107
1108         fs_info = btrfs_new_fs_info(flags & OPEN_CTREE_WRITES, sb_bytenr);
1109         if (!fs_info) {
1110                 fprintf(stderr, "Failed to allocate memory for fs_info\n");
1111                 return NULL;
1112         }
1113         if (flags & OPEN_CTREE_RESTORE)
1114                 fs_info->on_restoring = 1;
1115
1116         ret = btrfs_scan_fs_devices(fp, path, &fs_devices, sb_bytenr,
1117                                     (flags & OPEN_CTREE_RECOVER_SUPER));
1118         if (ret)
1119                 goto out;
1120
1121         fs_info->fs_devices = fs_devices;
1122         if (flags & OPEN_CTREE_WRITES)
1123                 oflags = O_RDWR;
1124         else
1125                 oflags = O_RDONLY;
1126
1127         if (flags & OPEN_CTREE_EXCLUSIVE)
1128                 oflags |= O_EXCL;
1129
1130         ret = btrfs_open_devices(fs_devices, oflags);
1131         if (ret)
1132                 goto out;
1133
1134         disk_super = fs_info->super_copy;
1135         if (!(flags & OPEN_CTREE_RECOVER_SUPER))
1136                 ret = btrfs_read_dev_super(fs_devices->latest_bdev,
1137                                            disk_super, sb_bytenr, 1);
1138         else
1139                 ret = btrfs_read_dev_super(fp, disk_super, sb_bytenr, 0);
1140         if (ret) {
1141                 printk("No valid btrfs found\n");
1142                 goto out_devices;
1143         }
1144
1145         memcpy(fs_info->fsid, &disk_super->fsid, BTRFS_FSID_SIZE);
1146
1147         ret = btrfs_check_fs_compatibility(fs_info->super_copy,
1148                                            flags & OPEN_CTREE_WRITES);
1149         if (ret)
1150                 goto out_devices;
1151
1152         ret = btrfs_setup_chunk_tree_and_device_map(fs_info);
1153         if (ret)
1154                 goto out_chunk;
1155
1156         eb = fs_info->chunk_root->node;
1157         read_extent_buffer(eb, fs_info->chunk_tree_uuid,
1158                            btrfs_header_chunk_tree_uuid(eb),
1159                            BTRFS_UUID_SIZE);
1160
1161         ret = btrfs_setup_all_roots(fs_info, root_tree_bytenr, flags);
1162         if (ret)
1163                 goto out_chunk;
1164
1165         return fs_info;
1166
1167 out_chunk:
1168         btrfs_release_all_roots(fs_info);
1169         btrfs_cleanup_all_caches(fs_info);
1170 out_devices:
1171         btrfs_close_devices(fs_devices);
1172 out:
1173         btrfs_free_fs_info(fs_info);
1174         return NULL;
1175 }
1176
1177 struct btrfs_fs_info *open_ctree_fs_info(const char *filename,
1178                                          u64 sb_bytenr, u64 root_tree_bytenr,
1179                                          enum btrfs_open_ctree_flags flags)
1180 {
1181         int fp;
1182         struct btrfs_fs_info *info;
1183         int oflags = O_CREAT | O_RDWR;
1184
1185         if (!(flags & OPEN_CTREE_WRITES))
1186                 oflags = O_RDONLY;
1187
1188         fp = open(filename, oflags, 0600);
1189         if (fp < 0) {
1190                 fprintf (stderr, "Could not open %s\n", filename);
1191                 return NULL;
1192         }
1193         info = __open_ctree_fd(fp, filename, sb_bytenr, root_tree_bytenr,
1194                                flags);
1195         close(fp);
1196         return info;
1197 }
1198
1199 struct btrfs_root *open_ctree(const char *filename, u64 sb_bytenr,
1200                               enum btrfs_open_ctree_flags flags)
1201 {
1202         struct btrfs_fs_info *info;
1203
1204         info = open_ctree_fs_info(filename, sb_bytenr, 0, flags);
1205         if (!info)
1206                 return NULL;
1207         return info->fs_root;
1208 }
1209
1210 struct btrfs_root *open_ctree_fd(int fp, const char *path, u64 sb_bytenr,
1211                                  enum btrfs_open_ctree_flags flags)
1212 {
1213         struct btrfs_fs_info *info;
1214         info = __open_ctree_fd(fp, path, sb_bytenr, 0, flags);
1215         if (!info)
1216                 return NULL;
1217         return info->fs_root;
1218 }
1219
1220 int btrfs_read_dev_super(int fd, struct btrfs_super_block *sb, u64 sb_bytenr,
1221                          int super_recover)
1222 {
1223         u8 fsid[BTRFS_FSID_SIZE];
1224         int fsid_is_initialized = 0;
1225         struct btrfs_super_block buf;
1226         int i;
1227         int ret;
1228         int max_super = super_recover ? BTRFS_SUPER_MIRROR_MAX : 1;
1229         u64 transid = 0;
1230         u64 bytenr;
1231
1232         if (sb_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1233                 ret = pread64(fd, &buf, sizeof(buf), sb_bytenr);
1234                 if (ret < sizeof(buf))
1235                         return -1;
1236
1237                 if (btrfs_super_bytenr(&buf) != sb_bytenr ||
1238                     btrfs_super_magic(&buf) != BTRFS_MAGIC)
1239                         return -1;
1240
1241                 memcpy(sb, &buf, sizeof(*sb));
1242                 return 0;
1243         }
1244
1245         /*
1246         * we would like to check all the supers, but that would make
1247         * a btrfs mount succeed after a mkfs from a different FS.
1248         * So, we need to add a special mount option to scan for
1249         * later supers, using BTRFS_SUPER_MIRROR_MAX instead
1250         */
1251
1252         for (i = 0; i < max_super; i++) {
1253                 bytenr = btrfs_sb_offset(i);
1254                 ret = pread64(fd, &buf, sizeof(buf), bytenr);
1255                 if (ret < sizeof(buf))
1256                         break;
1257
1258                 if (btrfs_super_bytenr(&buf) != bytenr )
1259                         continue;
1260                 /* if magic is NULL, the device was removed */
1261                 if (btrfs_super_magic(&buf) == 0 && i == 0)
1262                         return -1;
1263                 if (btrfs_super_magic(&buf) != BTRFS_MAGIC)
1264                         continue;
1265
1266                 if (!fsid_is_initialized) {
1267                         memcpy(fsid, buf.fsid, sizeof(fsid));
1268                         fsid_is_initialized = 1;
1269                 } else if (memcmp(fsid, buf.fsid, sizeof(fsid))) {
1270                         /*
1271                          * the superblocks (the original one and
1272                          * its backups) contain data of different
1273                          * filesystems -> the super cannot be trusted
1274                          */
1275                         continue;
1276                 }
1277
1278                 if (btrfs_super_generation(&buf) > transid) {
1279                         memcpy(sb, &buf, sizeof(*sb));
1280                         transid = btrfs_super_generation(&buf);
1281                 }
1282         }
1283
1284         return transid > 0 ? 0 : -1;
1285 }
1286
1287 static int write_dev_supers(struct btrfs_root *root,
1288                             struct btrfs_super_block *sb,
1289                             struct btrfs_device *device)
1290 {
1291         u64 bytenr;
1292         u32 crc;
1293         int i, ret;
1294
1295         if (root->fs_info->super_bytenr != BTRFS_SUPER_INFO_OFFSET) {
1296                 btrfs_set_super_bytenr(sb, root->fs_info->super_bytenr);
1297                 crc = ~(u32)0;
1298                 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1299                                       BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1300                 btrfs_csum_final(crc, (char *)&sb->csum[0]);
1301
1302                 /*
1303                  * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1304                  * zero filled, we can use it directly
1305                  */
1306                 ret = pwrite64(device->fd, root->fs_info->super_copy,
1307                                 BTRFS_SUPER_INFO_SIZE,
1308                                 root->fs_info->super_bytenr);
1309                 BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);
1310                 return 0;
1311         }
1312
1313         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
1314                 bytenr = btrfs_sb_offset(i);
1315                 if (bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)
1316                         break;
1317
1318                 btrfs_set_super_bytenr(sb, bytenr);
1319
1320                 crc = ~(u32)0;
1321                 crc = btrfs_csum_data(NULL, (char *)sb + BTRFS_CSUM_SIZE, crc,
1322                                       BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
1323                 btrfs_csum_final(crc, (char *)&sb->csum[0]);
1324
1325                 /*
1326                  * super_copy is BTRFS_SUPER_INFO_SIZE bytes and is
1327                  * zero filled, we can use it directly
1328                  */
1329                 ret = pwrite64(device->fd, root->fs_info->super_copy,
1330                                 BTRFS_SUPER_INFO_SIZE, bytenr);
1331                 BUG_ON(ret != BTRFS_SUPER_INFO_SIZE);
1332         }
1333
1334         return 0;
1335 }
1336
1337 int write_all_supers(struct btrfs_root *root)
1338 {
1339         struct list_head *cur;
1340         struct list_head *head = &root->fs_info->fs_devices->devices;
1341         struct btrfs_device *dev;
1342         struct btrfs_super_block *sb;
1343         struct btrfs_dev_item *dev_item;
1344         int ret;
1345         u64 flags;
1346
1347         sb = root->fs_info->super_copy;
1348         dev_item = &sb->dev_item;
1349         list_for_each(cur, head) {
1350                 dev = list_entry(cur, struct btrfs_device, dev_list);
1351                 if (!dev->writeable)
1352                         continue;
1353
1354                 btrfs_set_stack_device_generation(dev_item, 0);
1355                 btrfs_set_stack_device_type(dev_item, dev->type);
1356                 btrfs_set_stack_device_id(dev_item, dev->devid);
1357                 btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
1358                 btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
1359                 btrfs_set_stack_device_io_align(dev_item, dev->io_align);
1360                 btrfs_set_stack_device_io_width(dev_item, dev->io_width);
1361                 btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
1362                 memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
1363                 memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
1364
1365                 flags = btrfs_super_flags(sb);
1366                 btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
1367
1368                 ret = write_dev_supers(root, sb, dev);
1369                 BUG_ON(ret);
1370         }
1371         return 0;
1372 }
1373
1374 int write_ctree_super(struct btrfs_trans_handle *trans,
1375                       struct btrfs_root *root)
1376 {
1377         int ret;
1378         struct btrfs_root *tree_root = root->fs_info->tree_root;
1379         struct btrfs_root *chunk_root = root->fs_info->chunk_root;
1380
1381         if (root->fs_info->readonly)
1382                 return 0;
1383
1384         btrfs_set_super_generation(root->fs_info->super_copy,
1385                                    trans->transid);
1386         btrfs_set_super_root(root->fs_info->super_copy,
1387                              tree_root->node->start);
1388         btrfs_set_super_root_level(root->fs_info->super_copy,
1389                                    btrfs_header_level(tree_root->node));
1390         btrfs_set_super_chunk_root(root->fs_info->super_copy,
1391                                    chunk_root->node->start);
1392         btrfs_set_super_chunk_root_level(root->fs_info->super_copy,
1393                                          btrfs_header_level(chunk_root->node));
1394         btrfs_set_super_chunk_root_generation(root->fs_info->super_copy,
1395                                 btrfs_header_generation(chunk_root->node));
1396
1397         ret = write_all_supers(root);
1398         if (ret)
1399                 fprintf(stderr, "failed to write new super block err %d\n", ret);
1400         return ret;
1401 }
1402
1403 int close_ctree(struct btrfs_root *root)
1404 {
1405         int ret;
1406         struct btrfs_trans_handle *trans;
1407         struct btrfs_fs_info *fs_info = root->fs_info;
1408
1409         if (fs_info->last_trans_committed !=
1410             fs_info->generation) {
1411                 trans = btrfs_start_transaction(root, 1);
1412                 btrfs_commit_transaction(trans, root);
1413                 trans = btrfs_start_transaction(root, 1);
1414                 ret = commit_tree_roots(trans, fs_info);
1415                 BUG_ON(ret);
1416                 ret = __commit_transaction(trans, root);
1417                 BUG_ON(ret);
1418                 write_ctree_super(trans, root);
1419                 btrfs_free_transaction(root, trans);
1420         }
1421         btrfs_free_block_groups(fs_info);
1422
1423         free_fs_roots_tree(&fs_info->fs_root_tree);
1424
1425         btrfs_release_all_roots(fs_info);
1426         btrfs_close_devices(fs_info->fs_devices);
1427         btrfs_cleanup_all_caches(fs_info);
1428         btrfs_free_fs_info(fs_info);
1429         return 0;
1430 }
1431
1432 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1433                      struct extent_buffer *eb)
1434 {
1435         return clear_extent_buffer_dirty(eb);
1436 }
1437
1438 int wait_on_tree_block_writeback(struct btrfs_root *root,
1439                                  struct extent_buffer *eb)
1440 {
1441         return 0;
1442 }
1443
1444 void btrfs_mark_buffer_dirty(struct extent_buffer *eb)
1445 {
1446         set_extent_buffer_dirty(eb);
1447 }
1448
1449 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
1450 {
1451         int ret;
1452
1453         ret = extent_buffer_uptodate(buf);
1454         if (!ret)
1455                 return ret;
1456
1457         ret = verify_parent_transid(buf->tree, buf, parent_transid, 1);
1458         return !ret;
1459 }
1460
1461 int btrfs_set_buffer_uptodate(struct extent_buffer *eb)
1462 {
1463         return set_extent_buffer_uptodate(eb);
1464 }