linux/fs/btrfs/disk-io.c
<<
>>
Prefs
   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 <linux/fs.h>
  20#include <linux/blkdev.h>
  21#include <linux/scatterlist.h>
  22#include <linux/swap.h>
  23#include <linux/radix-tree.h>
  24#include <linux/writeback.h>
  25#include <linux/buffer_head.h>
  26#include <linux/workqueue.h>
  27#include <linux/kthread.h>
  28#include <linux/freezer.h>
  29#include <linux/crc32c.h>
  30#include <linux/slab.h>
  31#include <linux/migrate.h>
  32#include <linux/ratelimit.h>
  33#include <asm/unaligned.h>
  34#include "compat.h"
  35#include "ctree.h"
  36#include "disk-io.h"
  37#include "transaction.h"
  38#include "btrfs_inode.h"
  39#include "volumes.h"
  40#include "print-tree.h"
  41#include "async-thread.h"
  42#include "locking.h"
  43#include "tree-log.h"
  44#include "free-space-cache.h"
  45#include "inode-map.h"
  46#include "check-integrity.h"
  47#include "rcu-string.h"
  48
  49static struct extent_io_ops btree_extent_io_ops;
  50static void end_workqueue_fn(struct btrfs_work *work);
  51static void free_fs_root(struct btrfs_root *root);
  52static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
  53                                    int read_only);
  54static void btrfs_destroy_ordered_operations(struct btrfs_root *root);
  55static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
  56static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
  57                                      struct btrfs_root *root);
  58static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
  59static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
  60static int btrfs_destroy_marked_extents(struct btrfs_root *root,
  61                                        struct extent_io_tree *dirty_pages,
  62                                        int mark);
  63static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
  64                                       struct extent_io_tree *pinned_extents);
  65
  66/*
  67 * end_io_wq structs are used to do processing in task context when an IO is
  68 * complete.  This is used during reads to verify checksums, and it is used
  69 * by writes to insert metadata for new file extents after IO is complete.
  70 */
  71struct end_io_wq {
  72        struct bio *bio;
  73        bio_end_io_t *end_io;
  74        void *private;
  75        struct btrfs_fs_info *info;
  76        int error;
  77        int metadata;
  78        struct list_head list;
  79        struct btrfs_work work;
  80};
  81
  82/*
  83 * async submit bios are used to offload expensive checksumming
  84 * onto the worker threads.  They checksum file and metadata bios
  85 * just before they are sent down the IO stack.
  86 */
  87struct async_submit_bio {
  88        struct inode *inode;
  89        struct bio *bio;
  90        struct list_head list;
  91        extent_submit_bio_hook_t *submit_bio_start;
  92        extent_submit_bio_hook_t *submit_bio_done;
  93        int rw;
  94        int mirror_num;
  95        unsigned long bio_flags;
  96        /*
  97         * bio_offset is optional, can be used if the pages in the bio
  98         * can't tell us where in the file the bio should go
  99         */
 100        u64 bio_offset;
 101        struct btrfs_work work;
 102        int error;
 103};
 104
 105/*
 106 * Lockdep class keys for extent_buffer->lock's in this root.  For a given
 107 * eb, the lockdep key is determined by the btrfs_root it belongs to and
 108 * the level the eb occupies in the tree.
 109 *
 110 * Different roots are used for different purposes and may nest inside each
 111 * other and they require separate keysets.  As lockdep keys should be
 112 * static, assign keysets according to the purpose of the root as indicated
 113 * by btrfs_root->objectid.  This ensures that all special purpose roots
 114 * have separate keysets.
 115 *
 116 * Lock-nesting across peer nodes is always done with the immediate parent
 117 * node locked thus preventing deadlock.  As lockdep doesn't know this, use
 118 * subclass to avoid triggering lockdep warning in such cases.
 119 *
 120 * The key is set by the readpage_end_io_hook after the buffer has passed
 121 * csum validation but before the pages are unlocked.  It is also set by
 122 * btrfs_init_new_buffer on freshly allocated blocks.
 123 *
 124 * We also add a check to make sure the highest level of the tree is the
 125 * same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this code
 126 * needs update as well.
 127 */
 128#ifdef CONFIG_DEBUG_LOCK_ALLOC
 129# if BTRFS_MAX_LEVEL != 8
 130#  error
 131# endif
 132
 133static struct btrfs_lockdep_keyset {
 134        u64                     id;             /* root objectid */
 135        const char              *name_stem;     /* lock name stem */
 136        char                    names[BTRFS_MAX_LEVEL + 1][20];
 137        struct lock_class_key   keys[BTRFS_MAX_LEVEL + 1];
 138} btrfs_lockdep_keysets[] = {
 139        { .id = BTRFS_ROOT_TREE_OBJECTID,       .name_stem = "root"     },
 140        { .id = BTRFS_EXTENT_TREE_OBJECTID,     .name_stem = "extent"   },
 141        { .id = BTRFS_CHUNK_TREE_OBJECTID,      .name_stem = "chunk"    },
 142        { .id = BTRFS_DEV_TREE_OBJECTID,        .name_stem = "dev"      },
 143        { .id = BTRFS_FS_TREE_OBJECTID,         .name_stem = "fs"       },
 144        { .id = BTRFS_CSUM_TREE_OBJECTID,       .name_stem = "csum"     },
 145        { .id = BTRFS_ORPHAN_OBJECTID,          .name_stem = "orphan"   },
 146        { .id = BTRFS_TREE_LOG_OBJECTID,        .name_stem = "log"      },
 147        { .id = BTRFS_TREE_RELOC_OBJECTID,      .name_stem = "treloc"   },
 148        { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc"   },
 149        { .id = 0,                              .name_stem = "tree"     },
 150};
 151
 152void __init btrfs_init_lockdep(void)
 153{
 154        int i, j;
 155
 156        /* initialize lockdep class names */
 157        for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
 158                struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];
 159
 160                for (j = 0; j < ARRAY_SIZE(ks->names); j++)
 161                        snprintf(ks->names[j], sizeof(ks->names[j]),
 162                                 "btrfs-%s-%02d", ks->name_stem, j);
 163        }
 164}
 165
 166void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
 167                                    int level)
 168{
 169        struct btrfs_lockdep_keyset *ks;
 170
 171        BUG_ON(level >= ARRAY_SIZE(ks->keys));
 172
 173        /* find the matching keyset, id 0 is the default entry */
 174        for (ks = btrfs_lockdep_keysets; ks->id; ks++)
 175                if (ks->id == objectid)
 176                        break;
 177
 178        lockdep_set_class_and_name(&eb->lock,
 179                                   &ks->keys[level], ks->names[level]);
 180}
 181
 182#endif
 183
 184/*
 185 * extents on the btree inode are pretty simple, there's one extent
 186 * that covers the entire device
 187 */
 188static struct extent_map *btree_get_extent(struct inode *inode,
 189                struct page *page, size_t pg_offset, u64 start, u64 len,
 190                int create)
 191{
 192        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
 193        struct extent_map *em;
 194        int ret;
 195
 196        read_lock(&em_tree->lock);
 197        em = lookup_extent_mapping(em_tree, start, len);
 198        if (em) {
 199                em->bdev =
 200                        BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
 201                read_unlock(&em_tree->lock);
 202                goto out;
 203        }
 204        read_unlock(&em_tree->lock);
 205
 206        em = alloc_extent_map();
 207        if (!em) {
 208                em = ERR_PTR(-ENOMEM);
 209                goto out;
 210        }
 211        em->start = 0;
 212        em->len = (u64)-1;
 213        em->block_len = (u64)-1;
 214        em->block_start = 0;
 215        em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
 216
 217        write_lock(&em_tree->lock);
 218        ret = add_extent_mapping(em_tree, em);
 219        if (ret == -EEXIST) {
 220                u64 failed_start = em->start;
 221                u64 failed_len = em->len;
 222
 223                free_extent_map(em);
 224                em = lookup_extent_mapping(em_tree, start, len);
 225                if (em) {
 226                        ret = 0;
 227                } else {
 228                        em = lookup_extent_mapping(em_tree, failed_start,
 229                                                   failed_len);
 230                        ret = -EIO;
 231                }
 232        } else if (ret) {
 233                free_extent_map(em);
 234                em = NULL;
 235        }
 236        write_unlock(&em_tree->lock);
 237
 238        if (ret)
 239                em = ERR_PTR(ret);
 240out:
 241        return em;
 242}
 243
 244u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
 245{
 246        return crc32c(seed, data, len);
 247}
 248
 249void btrfs_csum_final(u32 crc, char *result)
 250{
 251        put_unaligned_le32(~crc, result);
 252}
 253
 254/*
 255 * compute the csum for a btree block, and either verify it or write it
 256 * into the csum field of the block.
 257 */
 258static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
 259                           int verify)
 260{
 261        u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
 262        char *result = NULL;
 263        unsigned long len;
 264        unsigned long cur_len;
 265        unsigned long offset = BTRFS_CSUM_SIZE;
 266        char *kaddr;
 267        unsigned long map_start;
 268        unsigned long map_len;
 269        int err;
 270        u32 crc = ~(u32)0;
 271        unsigned long inline_result;
 272
 273        len = buf->len - offset;
 274        while (len > 0) {
 275                err = map_private_extent_buffer(buf, offset, 32,
 276                                        &kaddr, &map_start, &map_len);
 277                if (err)
 278                        return 1;
 279                cur_len = min(len, map_len - (offset - map_start));
 280                crc = btrfs_csum_data(root, kaddr + offset - map_start,
 281                                      crc, cur_len);
 282                len -= cur_len;
 283                offset += cur_len;
 284        }
 285        if (csum_size > sizeof(inline_result)) {
 286                result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
 287                if (!result)
 288                        return 1;
 289        } else {
 290                result = (char *)&inline_result;
 291        }
 292
 293        btrfs_csum_final(crc, result);
 294
 295        if (verify) {
 296                if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
 297                        u32 val;
 298                        u32 found = 0;
 299                        memcpy(&found, result, csum_size);
 300
 301                        read_extent_buffer(buf, &val, 0, csum_size);
 302                        printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
 303                                       "failed on %llu wanted %X found %X "
 304                                       "level %d\n",
 305                                       root->fs_info->sb->s_id,
 306                                       (unsigned long long)buf->start, val, found,
 307                                       btrfs_header_level(buf));
 308                        if (result != (char *)&inline_result)
 309                                kfree(result);
 310                        return 1;
 311                }
 312        } else {
 313                write_extent_buffer(buf, result, 0, csum_size);
 314        }
 315        if (result != (char *)&inline_result)
 316                kfree(result);
 317        return 0;
 318}
 319
 320/*
 321 * we can't consider a given block up to date unless the transid of the
 322 * block matches the transid in the parent node's pointer.  This is how we
 323 * detect blocks that either didn't get written at all or got written
 324 * in the wrong place.
 325 */
 326static int verify_parent_transid(struct extent_io_tree *io_tree,
 327                                 struct extent_buffer *eb, u64 parent_transid,
 328                                 int atomic)
 329{
 330        struct extent_state *cached_state = NULL;
 331        int ret;
 332
 333        if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
 334                return 0;
 335
 336        if (atomic)
 337                return -EAGAIN;
 338
 339        lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
 340                         0, &cached_state);
 341        if (extent_buffer_uptodate(eb) &&
 342            btrfs_header_generation(eb) == parent_transid) {
 343                ret = 0;
 344                goto out;
 345        }
 346        printk_ratelimited("parent transid verify failed on %llu wanted %llu "
 347                       "found %llu\n",
 348                       (unsigned long long)eb->start,
 349                       (unsigned long long)parent_transid,
 350                       (unsigned long long)btrfs_header_generation(eb));
 351        ret = 1;
 352        clear_extent_buffer_uptodate(eb);
 353out:
 354        unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
 355                             &cached_state, GFP_NOFS);
 356        return ret;
 357}
 358
 359/*
 360 * helper to read a given tree block, doing retries as required when
 361 * the checksums don't match and we have alternate mirrors to try.
 362 */
 363static int btree_read_extent_buffer_pages(struct btrfs_root *root,
 364                                          struct extent_buffer *eb,
 365                                          u64 start, u64 parent_transid)
 366{
 367        struct extent_io_tree *io_tree;
 368        int failed = 0;
 369        int ret;
 370        int num_copies = 0;
 371        int mirror_num = 0;
 372        int failed_mirror = 0;
 373
 374        clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 375        io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
 376        while (1) {
 377                ret = read_extent_buffer_pages(io_tree, eb, start,
 378                                               WAIT_COMPLETE,
 379                                               btree_get_extent, mirror_num);
 380                if (!ret) {
 381                        if (!verify_parent_transid(io_tree, eb,
 382                                                   parent_transid, 0))
 383                                break;
 384                        else
 385                                ret = -EIO;
 386                }
 387
 388                /*
 389                 * This buffer's crc is fine, but its contents are corrupted, so
 390                 * there is no reason to read the other copies, they won't be
 391                 * any less wrong.
 392                 */
 393                if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
 394                        break;
 395
 396                num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
 397                                              eb->start, eb->len);
 398                if (num_copies == 1)
 399                        break;
 400
 401                if (!failed_mirror) {
 402                        failed = 1;
 403                        failed_mirror = eb->read_mirror;
 404                }
 405
 406                mirror_num++;
 407                if (mirror_num == failed_mirror)
 408                        mirror_num++;
 409
 410                if (mirror_num > num_copies)
 411                        break;
 412        }
 413
 414        if (failed && !ret && failed_mirror)
 415                repair_eb_io_failure(root, eb, failed_mirror);
 416
 417        return ret;
 418}
 419
 420/*
 421 * checksum a dirty tree block before IO.  This has extra checks to make sure
 422 * we only fill in the checksum field in the first page of a multi-page block
 423 */
 424
 425static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
 426{
 427        struct extent_io_tree *tree;
 428        u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
 429        u64 found_start;
 430        struct extent_buffer *eb;
 431
 432        tree = &BTRFS_I(page->mapping->host)->io_tree;
 433
 434        eb = (struct extent_buffer *)page->private;
 435        if (page != eb->pages[0])
 436                return 0;
 437        found_start = btrfs_header_bytenr(eb);
 438        if (found_start != start) {
 439                WARN_ON(1);
 440                return 0;
 441        }
 442        if (eb->pages[0] != page) {
 443                WARN_ON(1);
 444                return 0;
 445        }
 446        if (!PageUptodate(page)) {
 447                WARN_ON(1);
 448                return 0;
 449        }
 450        csum_tree_block(root, eb, 0);
 451        return 0;
 452}
 453
 454static int check_tree_block_fsid(struct btrfs_root *root,
 455                                 struct extent_buffer *eb)
 456{
 457        struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
 458        u8 fsid[BTRFS_UUID_SIZE];
 459        int ret = 1;
 460
 461        read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
 462                           BTRFS_FSID_SIZE);
 463        while (fs_devices) {
 464                if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
 465                        ret = 0;
 466                        break;
 467                }
 468                fs_devices = fs_devices->seed;
 469        }
 470        return ret;
 471}
 472
 473#define CORRUPT(reason, eb, root, slot)                         \
 474        printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu," \
 475               "root=%llu, slot=%d\n", reason,                  \
 476               (unsigned long long)btrfs_header_bytenr(eb),     \
 477               (unsigned long long)root->objectid, slot)
 478
 479static noinline int check_leaf(struct btrfs_root *root,
 480                               struct extent_buffer *leaf)
 481{
 482        struct btrfs_key key;
 483        struct btrfs_key leaf_key;
 484        u32 nritems = btrfs_header_nritems(leaf);
 485        int slot;
 486
 487        if (nritems == 0)
 488                return 0;
 489
 490        /* Check the 0 item */
 491        if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
 492            BTRFS_LEAF_DATA_SIZE(root)) {
 493                CORRUPT("invalid item offset size pair", leaf, root, 0);
 494                return -EIO;
 495        }
 496
 497        /*
 498         * Check to make sure each items keys are in the correct order and their
 499         * offsets make sense.  We only have to loop through nritems-1 because
 500         * we check the current slot against the next slot, which verifies the
 501         * next slot's offset+size makes sense and that the current's slot
 502         * offset is correct.
 503         */
 504        for (slot = 0; slot < nritems - 1; slot++) {
 505                btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
 506                btrfs_item_key_to_cpu(leaf, &key, slot + 1);
 507
 508                /* Make sure the keys are in the right order */
 509                if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
 510                        CORRUPT("bad key order", leaf, root, slot);
 511                        return -EIO;
 512                }
 513
 514                /*
 515                 * Make sure the offset and ends are right, remember that the
 516                 * item data starts at the end of the leaf and grows towards the
 517                 * front.
 518                 */
 519                if (btrfs_item_offset_nr(leaf, slot) !=
 520                        btrfs_item_end_nr(leaf, slot + 1)) {
 521                        CORRUPT("slot offset bad", leaf, root, slot);
 522                        return -EIO;
 523                }
 524
 525                /*
 526                 * Check to make sure that we don't point outside of the leaf,
 527                 * just incase all the items are consistent to eachother, but
 528                 * all point outside of the leaf.
 529                 */
 530                if (btrfs_item_end_nr(leaf, slot) >
 531                    BTRFS_LEAF_DATA_SIZE(root)) {
 532                        CORRUPT("slot end outside of leaf", leaf, root, slot);
 533                        return -EIO;
 534                }
 535        }
 536
 537        return 0;
 538}
 539
 540struct extent_buffer *find_eb_for_page(struct extent_io_tree *tree,
 541                                       struct page *page, int max_walk)
 542{
 543        struct extent_buffer *eb;
 544        u64 start = page_offset(page);
 545        u64 target = start;
 546        u64 min_start;
 547
 548        if (start < max_walk)
 549                min_start = 0;
 550        else
 551                min_start = start - max_walk;
 552
 553        while (start >= min_start) {
 554                eb = find_extent_buffer(tree, start, 0);
 555                if (eb) {
 556                        /*
 557                         * we found an extent buffer and it contains our page
 558                         * horray!
 559                         */
 560                        if (eb->start <= target &&
 561                            eb->start + eb->len > target)
 562                                return eb;
 563
 564                        /* we found an extent buffer that wasn't for us */
 565                        free_extent_buffer(eb);
 566                        return NULL;
 567                }
 568                if (start == 0)
 569                        break;
 570                start -= PAGE_CACHE_SIZE;
 571        }
 572        return NULL;
 573}
 574
 575static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
 576                               struct extent_state *state, int mirror)
 577{
 578        struct extent_io_tree *tree;
 579        u64 found_start;
 580        int found_level;
 581        struct extent_buffer *eb;
 582        struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 583        int ret = 0;
 584        int reads_done;
 585
 586        if (!page->private)
 587                goto out;
 588
 589        tree = &BTRFS_I(page->mapping->host)->io_tree;
 590        eb = (struct extent_buffer *)page->private;
 591
 592        /* the pending IO might have been the only thing that kept this buffer
 593         * in memory.  Make sure we have a ref for all this other checks
 594         */
 595        extent_buffer_get(eb);
 596
 597        reads_done = atomic_dec_and_test(&eb->io_pages);
 598        if (!reads_done)
 599                goto err;
 600
 601        eb->read_mirror = mirror;
 602        if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
 603                ret = -EIO;
 604                goto err;
 605        }
 606
 607        found_start = btrfs_header_bytenr(eb);
 608        if (found_start != eb->start) {
 609                printk_ratelimited(KERN_INFO "btrfs bad tree block start "
 610                               "%llu %llu\n",
 611                               (unsigned long long)found_start,
 612                               (unsigned long long)eb->start);
 613                ret = -EIO;
 614                goto err;
 615        }
 616        if (check_tree_block_fsid(root, eb)) {
 617                printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
 618                               (unsigned long long)eb->start);
 619                ret = -EIO;
 620                goto err;
 621        }
 622        found_level = btrfs_header_level(eb);
 623
 624        btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
 625                                       eb, found_level);
 626
 627        ret = csum_tree_block(root, eb, 1);
 628        if (ret) {
 629                ret = -EIO;
 630                goto err;
 631        }
 632
 633        /*
 634         * If this is a leaf block and it is corrupt, set the corrupt bit so
 635         * that we don't try and read the other copies of this block, just
 636         * return -EIO.
 637         */
 638        if (found_level == 0 && check_leaf(root, eb)) {
 639                set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
 640                ret = -EIO;
 641        }
 642
 643        if (!ret)
 644                set_extent_buffer_uptodate(eb);
 645err:
 646        if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
 647                clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
 648                btree_readahead_hook(root, eb, eb->start, ret);
 649        }
 650
 651        if (ret)
 652                clear_extent_buffer_uptodate(eb);
 653        free_extent_buffer(eb);
 654out:
 655        return ret;
 656}
 657
 658static int btree_io_failed_hook(struct page *page, int failed_mirror)
 659{
 660        struct extent_buffer *eb;
 661        struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 662
 663        eb = (struct extent_buffer *)page->private;
 664        set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
 665        eb->read_mirror = failed_mirror;
 666        if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
 667                btree_readahead_hook(root, eb, eb->start, -EIO);
 668        return -EIO;    /* we fixed nothing */
 669}
 670
 671static void end_workqueue_bio(struct bio *bio, int err)
 672{
 673        struct end_io_wq *end_io_wq = bio->bi_private;
 674        struct btrfs_fs_info *fs_info;
 675
 676        fs_info = end_io_wq->info;
 677        end_io_wq->error = err;
 678        end_io_wq->work.func = end_workqueue_fn;
 679        end_io_wq->work.flags = 0;
 680
 681        if (bio->bi_rw & REQ_WRITE) {
 682                if (end_io_wq->metadata == 1)
 683                        btrfs_queue_worker(&fs_info->endio_meta_write_workers,
 684                                           &end_io_wq->work);
 685                else if (end_io_wq->metadata == 2)
 686                        btrfs_queue_worker(&fs_info->endio_freespace_worker,
 687                                           &end_io_wq->work);
 688                else
 689                        btrfs_queue_worker(&fs_info->endio_write_workers,
 690                                           &end_io_wq->work);
 691        } else {
 692                if (end_io_wq->metadata)
 693                        btrfs_queue_worker(&fs_info->endio_meta_workers,
 694                                           &end_io_wq->work);
 695                else
 696                        btrfs_queue_worker(&fs_info->endio_workers,
 697                                           &end_io_wq->work);
 698        }
 699}
 700
 701/*
 702 * For the metadata arg you want
 703 *
 704 * 0 - if data
 705 * 1 - if normal metadta
 706 * 2 - if writing to the free space cache area
 707 */
 708int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
 709                        int metadata)
 710{
 711        struct end_io_wq *end_io_wq;
 712        end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
 713        if (!end_io_wq)
 714                return -ENOMEM;
 715
 716        end_io_wq->private = bio->bi_private;
 717        end_io_wq->end_io = bio->bi_end_io;
 718        end_io_wq->info = info;
 719        end_io_wq->error = 0;
 720        end_io_wq->bio = bio;
 721        end_io_wq->metadata = metadata;
 722
 723        bio->bi_private = end_io_wq;
 724        bio->bi_end_io = end_workqueue_bio;
 725        return 0;
 726}
 727
 728unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
 729{
 730        unsigned long limit = min_t(unsigned long,
 731                                    info->workers.max_workers,
 732                                    info->fs_devices->open_devices);
 733        return 256 * limit;
 734}
 735
 736static void run_one_async_start(struct btrfs_work *work)
 737{
 738        struct async_submit_bio *async;
 739        int ret;
 740
 741        async = container_of(work, struct  async_submit_bio, work);
 742        ret = async->submit_bio_start(async->inode, async->rw, async->bio,
 743                                      async->mirror_num, async->bio_flags,
 744                                      async->bio_offset);
 745        if (ret)
 746                async->error = ret;
 747}
 748
 749static void run_one_async_done(struct btrfs_work *work)
 750{
 751        struct btrfs_fs_info *fs_info;
 752        struct async_submit_bio *async;
 753        int limit;
 754
 755        async = container_of(work, struct  async_submit_bio, work);
 756        fs_info = BTRFS_I(async->inode)->root->fs_info;
 757
 758        limit = btrfs_async_submit_limit(fs_info);
 759        limit = limit * 2 / 3;
 760
 761        if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
 762            waitqueue_active(&fs_info->async_submit_wait))
 763                wake_up(&fs_info->async_submit_wait);
 764
 765        /* If an error occured we just want to clean up the bio and move on */
 766        if (async->error) {
 767                bio_endio(async->bio, async->error);
 768                return;
 769        }
 770
 771        async->submit_bio_done(async->inode, async->rw, async->bio,
 772                               async->mirror_num, async->bio_flags,
 773                               async->bio_offset);
 774}
 775
 776static void run_one_async_free(struct btrfs_work *work)
 777{
 778        struct async_submit_bio *async;
 779
 780        async = container_of(work, struct  async_submit_bio, work);
 781        kfree(async);
 782}
 783
 784int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
 785                        int rw, struct bio *bio, int mirror_num,
 786                        unsigned long bio_flags,
 787                        u64 bio_offset,
 788                        extent_submit_bio_hook_t *submit_bio_start,
 789                        extent_submit_bio_hook_t *submit_bio_done)
 790{
 791        struct async_submit_bio *async;
 792
 793        async = kmalloc(sizeof(*async), GFP_NOFS);
 794        if (!async)
 795                return -ENOMEM;
 796
 797        async->inode = inode;
 798        async->rw = rw;
 799        async->bio = bio;
 800        async->mirror_num = mirror_num;
 801        async->submit_bio_start = submit_bio_start;
 802        async->submit_bio_done = submit_bio_done;
 803
 804        async->work.func = run_one_async_start;
 805        async->work.ordered_func = run_one_async_done;
 806        async->work.ordered_free = run_one_async_free;
 807
 808        async->work.flags = 0;
 809        async->bio_flags = bio_flags;
 810        async->bio_offset = bio_offset;
 811
 812        async->error = 0;
 813
 814        atomic_inc(&fs_info->nr_async_submits);
 815
 816        if (rw & REQ_SYNC)
 817                btrfs_set_work_high_prio(&async->work);
 818
 819        btrfs_queue_worker(&fs_info->workers, &async->work);
 820
 821        while (atomic_read(&fs_info->async_submit_draining) &&
 822              atomic_read(&fs_info->nr_async_submits)) {
 823                wait_event(fs_info->async_submit_wait,
 824                           (atomic_read(&fs_info->nr_async_submits) == 0));
 825        }
 826
 827        return 0;
 828}
 829
 830static int btree_csum_one_bio(struct bio *bio)
 831{
 832        struct bio_vec *bvec = bio->bi_io_vec;
 833        int bio_index = 0;
 834        struct btrfs_root *root;
 835        int ret = 0;
 836
 837        WARN_ON(bio->bi_vcnt <= 0);
 838        while (bio_index < bio->bi_vcnt) {
 839                root = BTRFS_I(bvec->bv_page->mapping->host)->root;
 840                ret = csum_dirty_buffer(root, bvec->bv_page);
 841                if (ret)
 842                        break;
 843                bio_index++;
 844                bvec++;
 845        }
 846        return ret;
 847}
 848
 849static int __btree_submit_bio_start(struct inode *inode, int rw,
 850                                    struct bio *bio, int mirror_num,
 851                                    unsigned long bio_flags,
 852                                    u64 bio_offset)
 853{
 854        /*
 855         * when we're called for a write, we're already in the async
 856         * submission context.  Just jump into btrfs_map_bio
 857         */
 858        return btree_csum_one_bio(bio);
 859}
 860
 861static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
 862                                 int mirror_num, unsigned long bio_flags,
 863                                 u64 bio_offset)
 864{
 865        /*
 866         * when we're called for a write, we're already in the async
 867         * submission context.  Just jump into btrfs_map_bio
 868         */
 869        return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
 870}
 871
 872static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 873                                 int mirror_num, unsigned long bio_flags,
 874                                 u64 bio_offset)
 875{
 876        int ret;
 877
 878        if (!(rw & REQ_WRITE)) {
 879
 880                /*
 881                 * called for a read, do the setup so that checksum validation
 882                 * can happen in the async kernel threads
 883                 */
 884                ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
 885                                          bio, 1);
 886                if (ret)
 887                        return ret;
 888                return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
 889                                     mirror_num, 0);
 890        }
 891
 892        /*
 893         * kthread helpers are used to submit writes so that checksumming
 894         * can happen in parallel across all CPUs
 895         */
 896        return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
 897                                   inode, rw, bio, mirror_num, 0,
 898                                   bio_offset,
 899                                   __btree_submit_bio_start,
 900                                   __btree_submit_bio_done);
 901}
 902
 903#ifdef CONFIG_MIGRATION
 904static int btree_migratepage(struct address_space *mapping,
 905                        struct page *newpage, struct page *page,
 906                        enum migrate_mode mode)
 907{
 908        /*
 909         * we can't safely write a btree page from here,
 910         * we haven't done the locking hook
 911         */
 912        if (PageDirty(page))
 913                return -EAGAIN;
 914        /*
 915         * Buffers may be managed in a filesystem specific way.
 916         * We must have no buffers or drop them.
 917         */
 918        if (page_has_private(page) &&
 919            !try_to_release_page(page, GFP_KERNEL))
 920                return -EAGAIN;
 921        return migrate_page(mapping, newpage, page, mode);
 922}
 923#endif
 924
 925
 926static int btree_writepages(struct address_space *mapping,
 927                            struct writeback_control *wbc)
 928{
 929        struct extent_io_tree *tree;
 930        tree = &BTRFS_I(mapping->host)->io_tree;
 931        if (wbc->sync_mode == WB_SYNC_NONE) {
 932                struct btrfs_root *root = BTRFS_I(mapping->host)->root;
 933                u64 num_dirty;
 934                unsigned long thresh = 32 * 1024 * 1024;
 935
 936                if (wbc->for_kupdate)
 937                        return 0;
 938
 939                /* this is a bit racy, but that's ok */
 940                num_dirty = root->fs_info->dirty_metadata_bytes;
 941                if (num_dirty < thresh)
 942                        return 0;
 943        }
 944        return btree_write_cache_pages(mapping, wbc);
 945}
 946
 947static int btree_readpage(struct file *file, struct page *page)
 948{
 949        struct extent_io_tree *tree;
 950        tree = &BTRFS_I(page->mapping->host)->io_tree;
 951        return extent_read_full_page(tree, page, btree_get_extent, 0);
 952}
 953
 954static int btree_releasepage(struct page *page, gfp_t gfp_flags)
 955{
 956        if (PageWriteback(page) || PageDirty(page))
 957                return 0;
 958        /*
 959         * We need to mask out eg. __GFP_HIGHMEM and __GFP_DMA32 as we're doing
 960         * slab allocation from alloc_extent_state down the callchain where
 961         * it'd hit a BUG_ON as those flags are not allowed.
 962         */
 963        gfp_flags &= ~GFP_SLAB_BUG_MASK;
 964
 965        return try_release_extent_buffer(page, gfp_flags);
 966}
 967
 968static void btree_invalidatepage(struct page *page, unsigned long offset)
 969{
 970        struct extent_io_tree *tree;
 971        tree = &BTRFS_I(page->mapping->host)->io_tree;
 972        extent_invalidatepage(tree, page, offset);
 973        btree_releasepage(page, GFP_NOFS);
 974        if (PagePrivate(page)) {
 975                printk(KERN_WARNING "btrfs warning page private not zero "
 976                       "on page %llu\n", (unsigned long long)page_offset(page));
 977                ClearPagePrivate(page);
 978                set_page_private(page, 0);
 979                page_cache_release(page);
 980        }
 981}
 982
 983static int btree_set_page_dirty(struct page *page)
 984{
 985        struct extent_buffer *eb;
 986
 987        BUG_ON(!PagePrivate(page));
 988        eb = (struct extent_buffer *)page->private;
 989        BUG_ON(!eb);
 990        BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
 991        BUG_ON(!atomic_read(&eb->refs));
 992        btrfs_assert_tree_locked(eb);
 993        return __set_page_dirty_nobuffers(page);
 994}
 995
 996static const struct address_space_operations btree_aops = {
 997        .readpage       = btree_readpage,
 998        .writepages     = btree_writepages,
 999        .releasepage    = btree_releasepage,
1000        .invalidatepage = btree_invalidatepage,
1001#ifdef CONFIG_MIGRATION
1002        .migratepage    = btree_migratepage,
1003#endif
1004        .set_page_dirty = btree_set_page_dirty,
1005};
1006
1007int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1008                         u64 parent_transid)
1009{
1010        struct extent_buffer *buf = NULL;
1011        struct inode *btree_inode = root->fs_info->btree_inode;
1012        int ret = 0;
1013
1014        buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1015        if (!buf)
1016                return 0;
1017        read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1018                                 buf, 0, WAIT_NONE, btree_get_extent, 0);
1019        free_extent_buffer(buf);
1020        return ret;
1021}
1022
1023int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
1024                         int mirror_num, struct extent_buffer **eb)
1025{
1026        struct extent_buffer *buf = NULL;
1027        struct inode *btree_inode = root->fs_info->btree_inode;
1028        struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
1029        int ret;
1030
1031        buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1032        if (!buf)
1033                return 0;
1034
1035        set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);
1036
1037        ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
1038                                       btree_get_extent, mirror_num);
1039        if (ret) {
1040                free_extent_buffer(buf);
1041                return ret;
1042        }
1043
1044        if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
1045                free_extent_buffer(buf);
1046                return -EIO;
1047        } else if (extent_buffer_uptodate(buf)) {
1048                *eb = buf;
1049        } else {
1050                free_extent_buffer(buf);
1051        }
1052        return 0;
1053}
1054
1055struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
1056                                            u64 bytenr, u32 blocksize)
1057{
1058        struct inode *btree_inode = root->fs_info->btree_inode;
1059        struct extent_buffer *eb;
1060        eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1061                                bytenr, blocksize);
1062        return eb;
1063}
1064
1065struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
1066                                                 u64 bytenr, u32 blocksize)
1067{
1068        struct inode *btree_inode = root->fs_info->btree_inode;
1069        struct extent_buffer *eb;
1070
1071        eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1072                                 bytenr, blocksize);
1073        return eb;
1074}
1075
1076
1077int btrfs_write_tree_block(struct extent_buffer *buf)
1078{
1079        return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1080                                        buf->start + buf->len - 1);
1081}
1082
1083int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1084{
1085        return filemap_fdatawait_range(buf->pages[0]->mapping,
1086                                       buf->start, buf->start + buf->len - 1);
1087}
1088
1089struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1090                                      u32 blocksize, u64 parent_transid)
1091{
1092        struct extent_buffer *buf = NULL;
1093        int ret;
1094
1095        buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1096        if (!buf)
1097                return NULL;
1098
1099        ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1100        return buf;
1101
1102}
1103
1104void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1105                      struct extent_buffer *buf)
1106{
1107        if (btrfs_header_generation(buf) ==
1108            root->fs_info->running_transaction->transid) {
1109                btrfs_assert_tree_locked(buf);
1110
1111                if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1112                        spin_lock(&root->fs_info->delalloc_lock);
1113                        if (root->fs_info->dirty_metadata_bytes >= buf->len)
1114                                root->fs_info->dirty_metadata_bytes -= buf->len;
1115                        else {
1116                                spin_unlock(&root->fs_info->delalloc_lock);
1117                                btrfs_panic(root->fs_info, -EOVERFLOW,
1118                                          "Can't clear %lu bytes from "
1119                                          " dirty_mdatadata_bytes (%llu)",
1120                                          buf->len,
1121                                          root->fs_info->dirty_metadata_bytes);
1122                        }
1123                        spin_unlock(&root->fs_info->delalloc_lock);
1124                }
1125
1126                /* ugh, clear_extent_buffer_dirty needs to lock the page */
1127                btrfs_set_lock_blocking(buf);
1128                clear_extent_buffer_dirty(buf);
1129        }
1130}
1131
1132static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1133                         u32 stripesize, struct btrfs_root *root,
1134                         struct btrfs_fs_info *fs_info,
1135                         u64 objectid)
1136{
1137        root->node = NULL;
1138        root->commit_root = NULL;
1139        root->sectorsize = sectorsize;
1140        root->nodesize = nodesize;
1141        root->leafsize = leafsize;
1142        root->stripesize = stripesize;
1143        root->ref_cows = 0;
1144        root->track_dirty = 0;
1145        root->in_radix = 0;
1146        root->orphan_item_inserted = 0;
1147        root->orphan_cleanup_state = 0;
1148
1149        root->objectid = objectid;
1150        root->last_trans = 0;
1151        root->highest_objectid = 0;
1152        root->name = NULL;
1153        root->inode_tree = RB_ROOT;
1154        INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1155        root->block_rsv = NULL;
1156        root->orphan_block_rsv = NULL;
1157
1158        INIT_LIST_HEAD(&root->dirty_list);
1159        INIT_LIST_HEAD(&root->root_list);
1160        spin_lock_init(&root->orphan_lock);
1161        spin_lock_init(&root->inode_lock);
1162        spin_lock_init(&root->accounting_lock);
1163        mutex_init(&root->objectid_mutex);
1164        mutex_init(&root->log_mutex);
1165        init_waitqueue_head(&root->log_writer_wait);
1166        init_waitqueue_head(&root->log_commit_wait[0]);
1167        init_waitqueue_head(&root->log_commit_wait[1]);
1168        atomic_set(&root->log_commit[0], 0);
1169        atomic_set(&root->log_commit[1], 0);
1170        atomic_set(&root->log_writers, 0);
1171        atomic_set(&root->orphan_inodes, 0);
1172        root->log_batch = 0;
1173        root->log_transid = 0;
1174        root->last_log_commit = 0;
1175        extent_io_tree_init(&root->dirty_log_pages,
1176                             fs_info->btree_inode->i_mapping);
1177
1178        memset(&root->root_key, 0, sizeof(root->root_key));
1179        memset(&root->root_item, 0, sizeof(root->root_item));
1180        memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1181        memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1182        root->defrag_trans_start = fs_info->generation;
1183        init_completion(&root->kobj_unregister);
1184        root->defrag_running = 0;
1185        root->root_key.objectid = objectid;
1186        root->anon_dev = 0;
1187
1188        spin_lock_init(&root->root_times_lock);
1189}
1190
1191static int __must_check find_and_setup_root(struct btrfs_root *tree_root,
1192                                            struct btrfs_fs_info *fs_info,
1193                                            u64 objectid,
1194                                            struct btrfs_root *root)
1195{
1196        int ret;
1197        u32 blocksize;
1198        u64 generation;
1199
1200        __setup_root(tree_root->nodesize, tree_root->leafsize,
1201                     tree_root->sectorsize, tree_root->stripesize,
1202                     root, fs_info, objectid);
1203        ret = btrfs_find_last_root(tree_root, objectid,
1204                                   &root->root_item, &root->root_key);
1205        if (ret > 0)
1206                return -ENOENT;
1207        else if (ret < 0)
1208                return ret;
1209
1210        generation = btrfs_root_generation(&root->root_item);
1211        blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1212        root->commit_root = NULL;
1213        root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1214                                     blocksize, generation);
1215        if (!root->node || !btrfs_buffer_uptodate(root->node, generation, 0)) {
1216                free_extent_buffer(root->node);
1217                root->node = NULL;
1218                return -EIO;
1219        }
1220        root->commit_root = btrfs_root_node(root);
1221        return 0;
1222}
1223
1224static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
1225{
1226        struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
1227        if (root)
1228                root->fs_info = fs_info;
1229        return root;
1230}
1231
1232struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
1233                                     struct btrfs_fs_info *fs_info,
1234                                     u64 objectid)
1235{
1236        struct extent_buffer *leaf;
1237        struct btrfs_root *tree_root = fs_info->tree_root;
1238        struct btrfs_root *root;
1239        struct btrfs_key key;
1240        int ret = 0;
1241        u64 bytenr;
1242
1243        root = btrfs_alloc_root(fs_info);
1244        if (!root)
1245                return ERR_PTR(-ENOMEM);
1246
1247        __setup_root(tree_root->nodesize, tree_root->leafsize,
1248                     tree_root->sectorsize, tree_root->stripesize,
1249                     root, fs_info, objectid);
1250        root->root_key.objectid = objectid;
1251        root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1252        root->root_key.offset = 0;
1253
1254        leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
1255                                      0, objectid, NULL, 0, 0, 0);
1256        if (IS_ERR(leaf)) {
1257                ret = PTR_ERR(leaf);
1258                goto fail;
1259        }
1260
1261        bytenr = leaf->start;
1262        memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1263        btrfs_set_header_bytenr(leaf, leaf->start);
1264        btrfs_set_header_generation(leaf, trans->transid);
1265        btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1266        btrfs_set_header_owner(leaf, objectid);
1267        root->node = leaf;
1268
1269        write_extent_buffer(leaf, fs_info->fsid,
1270                            (unsigned long)btrfs_header_fsid(leaf),
1271                            BTRFS_FSID_SIZE);
1272        write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1273                            (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
1274                            BTRFS_UUID_SIZE);
1275        btrfs_mark_buffer_dirty(leaf);
1276
1277        root->commit_root = btrfs_root_node(root);
1278        root->track_dirty = 1;
1279
1280
1281        root->root_item.flags = 0;
1282        root->root_item.byte_limit = 0;
1283        btrfs_set_root_bytenr(&root->root_item, leaf->start);
1284        btrfs_set_root_generation(&root->root_item, trans->transid);
1285        btrfs_set_root_level(&root->root_item, 0);
1286        btrfs_set_root_refs(&root->root_item, 1);
1287        btrfs_set_root_used(&root->root_item, leaf->len);
1288        btrfs_set_root_last_snapshot(&root->root_item, 0);
1289        btrfs_set_root_dirid(&root->root_item, 0);
1290        root->root_item.drop_level = 0;
1291
1292        key.objectid = objectid;
1293        key.type = BTRFS_ROOT_ITEM_KEY;
1294        key.offset = 0;
1295        ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
1296        if (ret)
1297                goto fail;
1298
1299        btrfs_tree_unlock(leaf);
1300
1301fail:
1302        if (ret)
1303                return ERR_PTR(ret);
1304
1305        return root;
1306}
1307
1308static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
1309                                         struct btrfs_fs_info *fs_info)
1310{
1311        struct btrfs_root *root;
1312        struct btrfs_root *tree_root = fs_info->tree_root;
1313        struct extent_buffer *leaf;
1314
1315        root = btrfs_alloc_root(fs_info);
1316        if (!root)
1317                return ERR_PTR(-ENOMEM);
1318
1319        __setup_root(tree_root->nodesize, tree_root->leafsize,
1320                     tree_root->sectorsize, tree_root->stripesize,
1321                     root, fs_info, BTRFS_TREE_LOG_OBJECTID);
1322
1323        root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
1324        root->root_key.type = BTRFS_ROOT_ITEM_KEY;
1325        root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
1326        /*
1327         * log trees do not get reference counted because they go away
1328         * before a real commit is actually done.  They do store pointers
1329         * to file data extents, and those reference counts still get
1330         * updated (along with back refs to the log tree).
1331         */
1332        root->ref_cows = 0;
1333
1334        leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
1335                                      BTRFS_TREE_LOG_OBJECTID, NULL,
1336                                      0, 0, 0);
1337        if (IS_ERR(leaf)) {
1338                kfree(root);
1339                return ERR_CAST(leaf);
1340        }
1341
1342        memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
1343        btrfs_set_header_bytenr(leaf, leaf->start);
1344        btrfs_set_header_generation(leaf, trans->transid);
1345        btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
1346        btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
1347        root->node = leaf;
1348
1349        write_extent_buffer(root->node, root->fs_info->fsid,
1350                            (unsigned long)btrfs_header_fsid(root->node),
1351                            BTRFS_FSID_SIZE);
1352        btrfs_mark_buffer_dirty(root->node);
1353        btrfs_tree_unlock(root->node);
1354        return root;
1355}
1356
1357int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
1358                             struct btrfs_fs_info *fs_info)
1359{
1360        struct btrfs_root *log_root;
1361
1362        log_root = alloc_log_tree(trans, fs_info);
1363        if (IS_ERR(log_root))
1364                return PTR_ERR(log_root);
1365        WARN_ON(fs_info->log_root_tree);
1366        fs_info->log_root_tree = log_root;
1367        return 0;
1368}
1369
1370int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
1371                       struct btrfs_root *root)
1372{
1373        struct btrfs_root *log_root;
1374        struct btrfs_inode_item *inode_item;
1375
1376        log_root = alloc_log_tree(trans, root->fs_info);
1377        if (IS_ERR(log_root))
1378                return PTR_ERR(log_root);
1379
1380        log_root->last_trans = trans->transid;
1381        log_root->root_key.offset = root->root_key.objectid;
1382
1383        inode_item = &log_root->root_item.inode;
1384        inode_item->generation = cpu_to_le64(1);
1385        inode_item->size = cpu_to_le64(3);
1386        inode_item->nlink = cpu_to_le32(1);
1387        inode_item->nbytes = cpu_to_le64(root->leafsize);
1388        inode_item->mode = cpu_to_le32(S_IFDIR | 0755);
1389
1390        btrfs_set_root_node(&log_root->root_item, log_root->node);
1391
1392        WARN_ON(root->log_root);
1393        root->log_root = log_root;
1394        root->log_transid = 0;
1395        root->last_log_commit = 0;
1396        return 0;
1397}
1398
1399struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
1400                                               struct btrfs_key *location)
1401{
1402        struct btrfs_root *root;
1403        struct btrfs_fs_info *fs_info = tree_root->fs_info;
1404        struct btrfs_path *path;
1405        struct extent_buffer *l;
1406        u64 generation;
1407        u32 blocksize;
1408        int ret = 0;
1409        int slot;
1410
1411        root = btrfs_alloc_root(fs_info);
1412        if (!root)
1413                return ERR_PTR(-ENOMEM);
1414        if (location->offset == (u64)-1) {
1415                ret = find_and_setup_root(tree_root, fs_info,
1416                                          location->objectid, root);
1417                if (ret) {
1418                        kfree(root);
1419                        return ERR_PTR(ret);
1420                }
1421                goto out;
1422        }
1423
1424        __setup_root(tree_root->nodesize, tree_root->leafsize,
1425                     tree_root->sectorsize, tree_root->stripesize,
1426                     root, fs_info, location->objectid);
1427
1428        path = btrfs_alloc_path();
1429        if (!path) {
1430                kfree(root);
1431                return ERR_PTR(-ENOMEM);
1432        }
1433        ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1434        if (ret == 0) {
1435                l = path->nodes[0];
1436                slot = path->slots[0];
1437                btrfs_read_root_item(tree_root, l, slot, &root->root_item);
1438                memcpy(&root->root_key, location, sizeof(*location));
1439        }
1440        btrfs_free_path(path);
1441        if (ret) {
1442                kfree(root);
1443                if (ret > 0)
1444                        ret = -ENOENT;
1445                return ERR_PTR(ret);
1446        }
1447
1448        generation = btrfs_root_generation(&root->root_item);
1449        blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
1450        root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1451                                     blocksize, generation);
1452        root->commit_root = btrfs_root_node(root);
1453        BUG_ON(!root->node); /* -ENOMEM */
1454out:
1455        if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1456                root->ref_cows = 1;
1457                btrfs_check_and_init_root_item(&root->root_item);
1458        }
1459
1460        return root;
1461}
1462
1463struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
1464                                              struct btrfs_key *location)
1465{
1466        struct btrfs_root *root;
1467        int ret;
1468
1469        if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1470                return fs_info->tree_root;
1471        if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1472                return fs_info->extent_root;
1473        if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1474                return fs_info->chunk_root;
1475        if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1476                return fs_info->dev_root;
1477        if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1478                return fs_info->csum_root;
1479        if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1480                return fs_info->quota_root ? fs_info->quota_root :
1481                                             ERR_PTR(-ENOENT);
1482again:
1483        spin_lock(&fs_info->fs_roots_radix_lock);
1484        root = radix_tree_lookup(&fs_info->fs_roots_radix,
1485                                 (unsigned long)location->objectid);
1486        spin_unlock(&fs_info->fs_roots_radix_lock);
1487        if (root)
1488                return root;
1489
1490        root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1491        if (IS_ERR(root))
1492                return root;
1493
1494        root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
1495        root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
1496                                        GFP_NOFS);
1497        if (!root->free_ino_pinned || !root->free_ino_ctl) {
1498                ret = -ENOMEM;
1499                goto fail;
1500        }
1501
1502        btrfs_init_free_ino_ctl(root);
1503        mutex_init(&root->fs_commit_mutex);
1504        spin_lock_init(&root->cache_lock);
1505        init_waitqueue_head(&root->cache_wait);
1506
1507        ret = get_anon_bdev(&root->anon_dev);
1508        if (ret)
1509                goto fail;
1510
1511        if (btrfs_root_refs(&root->root_item) == 0) {
1512                ret = -ENOENT;
1513                goto fail;
1514        }
1515
1516        ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
1517        if (ret < 0)
1518                goto fail;
1519        if (ret == 0)
1520                root->orphan_item_inserted = 1;
1521
1522        ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
1523        if (ret)
1524                goto fail;
1525
1526        spin_lock(&fs_info->fs_roots_radix_lock);
1527        ret = radix_tree_insert(&fs_info->fs_roots_radix,
1528                                (unsigned long)root->root_key.objectid,
1529                                root);
1530        if (ret == 0)
1531                root->in_radix = 1;
1532
1533        spin_unlock(&fs_info->fs_roots_radix_lock);
1534        radix_tree_preload_end();
1535        if (ret) {
1536                if (ret == -EEXIST) {
1537                        free_fs_root(root);
1538                        goto again;
1539                }
1540                goto fail;
1541        }
1542
1543        ret = btrfs_find_dead_roots(fs_info->tree_root,
1544                                    root->root_key.objectid);
1545        WARN_ON(ret);
1546        return root;
1547fail:
1548        free_fs_root(root);
1549        return ERR_PTR(ret);
1550}
1551
1552static int btrfs_congested_fn(void *congested_data, int bdi_bits)
1553{
1554        struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
1555        int ret = 0;
1556        struct btrfs_device *device;
1557        struct backing_dev_info *bdi;
1558
1559        rcu_read_lock();
1560        list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1561                if (!device->bdev)
1562                        continue;
1563                bdi = blk_get_backing_dev_info(device->bdev);
1564                if (bdi && bdi_congested(bdi, bdi_bits)) {
1565                        ret = 1;
1566                        break;
1567                }
1568        }
1569        rcu_read_unlock();
1570        return ret;
1571}
1572
1573/*
1574 * If this fails, caller must call bdi_destroy() to get rid of the
1575 * bdi again.
1576 */
1577static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
1578{
1579        int err;
1580
1581        bdi->capabilities = BDI_CAP_MAP_COPY;
1582        err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1583        if (err)
1584                return err;
1585
1586        bdi->ra_pages   = default_backing_dev_info.ra_pages;
1587        bdi->congested_fn       = btrfs_congested_fn;
1588        bdi->congested_data     = info;
1589        return 0;
1590}
1591
1592/*
1593 * called by the kthread helper functions to finally call the bio end_io
1594 * functions.  This is where read checksum verification actually happens
1595 */
1596static void end_workqueue_fn(struct btrfs_work *work)
1597{
1598        struct bio *bio;
1599        struct end_io_wq *end_io_wq;
1600        struct btrfs_fs_info *fs_info;
1601        int error;
1602
1603        end_io_wq = container_of(work, struct end_io_wq, work);
1604        bio = end_io_wq->bio;
1605        fs_info = end_io_wq->info;
1606
1607        error = end_io_wq->error;
1608        bio->bi_private = end_io_wq->private;
1609        bio->bi_end_io = end_io_wq->end_io;
1610        kfree(end_io_wq);
1611        bio_endio(bio, error);
1612}
1613
1614static int cleaner_kthread(void *arg)
1615{
1616        struct btrfs_root *root = arg;
1617
1618        do {
1619                if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
1620                    mutex_trylock(&root->fs_info->cleaner_mutex)) {
1621                        btrfs_run_delayed_iputs(root);
1622                        btrfs_clean_old_snapshots(root);
1623                        mutex_unlock(&root->fs_info->cleaner_mutex);
1624                        btrfs_run_defrag_inodes(root->fs_info);
1625                }
1626
1627                if (!try_to_freeze()) {
1628                        set_current_state(TASK_INTERRUPTIBLE);
1629                        if (!kthread_should_stop())
1630                                schedule();
1631                        __set_current_state(TASK_RUNNING);
1632                }
1633        } while (!kthread_should_stop());
1634        return 0;
1635}
1636
1637static int transaction_kthread(void *arg)
1638{
1639        struct btrfs_root *root = arg;
1640        struct btrfs_trans_handle *trans;
1641        struct btrfs_transaction *cur;
1642        u64 transid;
1643        unsigned long now;
1644        unsigned long delay;
1645        bool cannot_commit;
1646
1647        do {
1648                cannot_commit = false;
1649                delay = HZ * 30;
1650                mutex_lock(&root->fs_info->transaction_kthread_mutex);
1651
1652                spin_lock(&root->fs_info->trans_lock);
1653                cur = root->fs_info->running_transaction;
1654                if (!cur) {
1655                        spin_unlock(&root->fs_info->trans_lock);
1656                        goto sleep;
1657                }
1658
1659                now = get_seconds();
1660                if (!cur->blocked &&
1661                    (now < cur->start_time || now - cur->start_time < 30)) {
1662                        spin_unlock(&root->fs_info->trans_lock);
1663                        delay = HZ * 5;
1664                        goto sleep;
1665                }
1666                transid = cur->transid;
1667                spin_unlock(&root->fs_info->trans_lock);
1668
1669                /* If the file system is aborted, this will always fail. */
1670                trans = btrfs_join_transaction(root);
1671                if (IS_ERR(trans)) {
1672                        cannot_commit = true;
1673                        goto sleep;
1674                }
1675                if (transid == trans->transid) {
1676                        btrfs_commit_transaction(trans, root);
1677                } else {
1678                        btrfs_end_transaction(trans, root);
1679                }
1680sleep:
1681                wake_up_process(root->fs_info->cleaner_kthread);
1682                mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1683
1684                if (!try_to_freeze()) {
1685                        set_current_state(TASK_INTERRUPTIBLE);
1686                        if (!kthread_should_stop() &&
1687                            (!btrfs_transaction_blocked(root->fs_info) ||
1688                             cannot_commit))
1689                                schedule_timeout(delay);
1690                        __set_current_state(TASK_RUNNING);
1691                }
1692        } while (!kthread_should_stop());
1693        return 0;
1694}
1695
1696/*
1697 * this will find the highest generation in the array of
1698 * root backups.  The index of the highest array is returned,
1699 * or -1 if we can't find anything.
1700 *
1701 * We check to make sure the array is valid by comparing the
1702 * generation of the latest  root in the array with the generation
1703 * in the super block.  If they don't match we pitch it.
1704 */
1705static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
1706{
1707        u64 cur;
1708        int newest_index = -1;
1709        struct btrfs_root_backup *root_backup;
1710        int i;
1711
1712        for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
1713                root_backup = info->super_copy->super_roots + i;
1714                cur = btrfs_backup_tree_root_gen(root_backup);
1715                if (cur == newest_gen)
1716                        newest_index = i;
1717        }
1718
1719        /* check to see if we actually wrapped around */
1720        if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
1721                root_backup = info->super_copy->super_roots;
1722                cur = btrfs_backup_tree_root_gen(root_backup);
1723                if (cur == newest_gen)
1724                        newest_index = 0;
1725        }
1726        return newest_index;
1727}
1728
1729
1730/*
1731 * find the oldest backup so we know where to store new entries
1732 * in the backup array.  This will set the backup_root_index
1733 * field in the fs_info struct
1734 */
1735static void find_oldest_super_backup(struct btrfs_fs_info *info,
1736                                     u64 newest_gen)
1737{
1738        int newest_index = -1;
1739
1740        newest_index = find_newest_super_backup(info, newest_gen);
1741        /* if there was garbage in there, just move along */
1742        if (newest_index == -1) {
1743                info->backup_root_index = 0;
1744        } else {
1745                info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
1746        }
1747}
1748
1749/*
1750 * copy all the root pointers into the super backup array.
1751 * this will bump the backup pointer by one when it is
1752 * done
1753 */
1754static void backup_super_roots(struct btrfs_fs_info *info)
1755{
1756        int next_backup;
1757        struct btrfs_root_backup *root_backup;
1758        int last_backup;
1759
1760        next_backup = info->backup_root_index;
1761        last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
1762                BTRFS_NUM_BACKUP_ROOTS;
1763
1764        /*
1765         * just overwrite the last backup if we're at the same generation
1766         * this happens only at umount
1767         */
1768        root_backup = info->super_for_commit->super_roots + last_backup;
1769        if (btrfs_backup_tree_root_gen(root_backup) ==
1770            btrfs_header_generation(info->tree_root->node))
1771                next_backup = last_backup;
1772
1773        root_backup = info->super_for_commit->super_roots + next_backup;
1774
1775        /*
1776         * make sure all of our padding and empty slots get zero filled
1777         * regardless of which ones we use today
1778         */
1779        memset(root_backup, 0, sizeof(*root_backup));
1780
1781        info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;
1782
1783        btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
1784        btrfs_set_backup_tree_root_gen(root_backup,
1785                               btrfs_header_generation(info->tree_root->node));
1786
1787        btrfs_set_backup_tree_root_level(root_backup,
1788                               btrfs_header_level(info->tree_root->node));
1789
1790        btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
1791        btrfs_set_backup_chunk_root_gen(root_backup,
1792                               btrfs_header_generation(info->chunk_root->node));
1793        btrfs_set_backup_chunk_root_level(root_backup,
1794                               btrfs_header_level(info->chunk_root->node));
1795
1796        btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
1797        btrfs_set_backup_extent_root_gen(root_backup,
1798                               btrfs_header_generation(info->extent_root->node));
1799        btrfs_set_backup_extent_root_level(root_backup,
1800                               btrfs_header_level(info->extent_root->node));
1801
1802        /*
1803         * we might commit during log recovery, which happens before we set
1804         * the fs_root.  Make sure it is valid before we fill it in.
1805         */
1806        if (info->fs_root && info->fs_root->node) {
1807                btrfs_set_backup_fs_root(root_backup,
1808                                         info->fs_root->node->start);
1809                btrfs_set_backup_fs_root_gen(root_backup,
1810                               btrfs_header_generation(info->fs_root->node));
1811                btrfs_set_backup_fs_root_level(root_backup,
1812                               btrfs_header_level(info->fs_root->node));
1813        }
1814
1815        btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
1816        btrfs_set_backup_dev_root_gen(root_backup,
1817                               btrfs_header_generation(info->dev_root->node));
1818        btrfs_set_backup_dev_root_level(root_backup,
1819                                       btrfs_header_level(info->dev_root->node));
1820
1821        btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
1822        btrfs_set_backup_csum_root_gen(root_backup,
1823                               btrfs_header_generation(info->csum_root->node));
1824        btrfs_set_backup_csum_root_level(root_backup,
1825                               btrfs_header_level(info->csum_root->node));
1826
1827        btrfs_set_backup_total_bytes(root_backup,
1828                             btrfs_super_total_bytes(info->super_copy));
1829        btrfs_set_backup_bytes_used(root_backup,
1830                             btrfs_super_bytes_used(info->super_copy));
1831        btrfs_set_backup_num_devices(root_backup,
1832                             btrfs_super_num_devices(info->super_copy));
1833
1834        /*
1835         * if we don't copy this out to the super_copy, it won't get remembered
1836         * for the next commit
1837         */
1838        memcpy(&info->super_copy->super_roots,
1839               &info->super_for_commit->super_roots,
1840               sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
1841}
1842
1843/*
1844 * this copies info out of the root backup array and back into
1845 * the in-memory super block.  It is meant to help iterate through
1846 * the array, so you send it the number of backups you've already
1847 * tried and the last backup index you used.
1848 *
1849 * this returns -1 when it has tried all the backups
1850 */
1851static noinline int next_root_backup(struct btrfs_fs_info *info,
1852                                     struct btrfs_super_block *super,
1853                                     int *num_backups_tried, int *backup_index)
1854{
1855        struct btrfs_root_backup *root_backup;
1856        int newest = *backup_index;
1857
1858        if (*num_backups_tried == 0) {
1859                u64 gen = btrfs_super_generation(super);
1860
1861                newest = find_newest_super_backup(info, gen);
1862                if (newest == -1)
1863                        return -1;
1864
1865                *backup_index = newest;
1866                *num_backups_tried = 1;
1867        } else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
1868                /* we've tried all the backups, all done */
1869                return -1;
1870        } else {
1871                /* jump to the next oldest backup */
1872                newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
1873                        BTRFS_NUM_BACKUP_ROOTS;
1874                *backup_index = newest;
1875                *num_backups_tried += 1;
1876        }
1877        root_backup = super->super_roots + newest;
1878
1879        btrfs_set_super_generation(super,
1880                                   btrfs_backup_tree_root_gen(root_backup));
1881        btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
1882        btrfs_set_super_root_level(super,
1883                                   btrfs_backup_tree_root_level(root_backup));
1884        btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));
1885
1886        /*
1887         * fixme: the total bytes and num_devices need to match or we should
1888         * need a fsck
1889         */
1890        btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
1891        btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
1892        return 0;
1893}
1894
1895/* helper to cleanup tree roots */
1896static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
1897{
1898        free_extent_buffer(info->tree_root->node);
1899        free_extent_buffer(info->tree_root->commit_root);
1900        free_extent_buffer(info->dev_root->node);
1901        free_extent_buffer(info->dev_root->commit_root);
1902        free_extent_buffer(info->extent_root->node);
1903        free_extent_buffer(info->extent_root->commit_root);
1904        free_extent_buffer(info->csum_root->node);
1905        free_extent_buffer(info->csum_root->commit_root);
1906        if (info->quota_root) {
1907                free_extent_buffer(info->quota_root->node);
1908                free_extent_buffer(info->quota_root->commit_root);
1909        }
1910
1911        info->tree_root->node = NULL;
1912        info->tree_root->commit_root = NULL;
1913        info->dev_root->node = NULL;
1914        info->dev_root->commit_root = NULL;
1915        info->extent_root->node = NULL;
1916        info->extent_root->commit_root = NULL;
1917        info->csum_root->node = NULL;
1918        info->csum_root->commit_root = NULL;
1919        if (info->quota_root) {
1920                info->quota_root->node = NULL;
1921                info->quota_root->commit_root = NULL;
1922        }
1923
1924        if (chunk_root) {
1925                free_extent_buffer(info->chunk_root->node);
1926                free_extent_buffer(info->chunk_root->commit_root);
1927                info->chunk_root->node = NULL;
1928                info->chunk_root->commit_root = NULL;
1929        }
1930}
1931
1932
1933int open_ctree(struct super_block *sb,
1934               struct btrfs_fs_devices *fs_devices,
1935               char *options)
1936{
1937        u32 sectorsize;
1938        u32 nodesize;
1939        u32 leafsize;
1940        u32 blocksize;
1941        u32 stripesize;
1942        u64 generation;
1943        u64 features;
1944        struct btrfs_key location;
1945        struct buffer_head *bh;
1946        struct btrfs_super_block *disk_super;
1947        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1948        struct btrfs_root *tree_root;
1949        struct btrfs_root *extent_root;
1950        struct btrfs_root *csum_root;
1951        struct btrfs_root *chunk_root;
1952        struct btrfs_root *dev_root;
1953        struct btrfs_root *quota_root;
1954        struct btrfs_root *log_tree_root;
1955        int ret;
1956        int err = -EINVAL;
1957        int num_backups_tried = 0;
1958        int backup_index = 0;
1959
1960        tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
1961        extent_root = fs_info->extent_root = btrfs_alloc_root(fs_info);
1962        csum_root = fs_info->csum_root = btrfs_alloc_root(fs_info);
1963        chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
1964        dev_root = fs_info->dev_root = btrfs_alloc_root(fs_info);
1965        quota_root = fs_info->quota_root = btrfs_alloc_root(fs_info);
1966
1967        if (!tree_root || !extent_root || !csum_root ||
1968            !chunk_root || !dev_root || !quota_root) {
1969                err = -ENOMEM;
1970                goto fail;
1971        }
1972
1973        ret = init_srcu_struct(&fs_info->subvol_srcu);
1974        if (ret) {
1975                err = ret;
1976                goto fail;
1977        }
1978
1979        ret = setup_bdi(fs_info, &fs_info->bdi);
1980        if (ret) {
1981                err = ret;
1982                goto fail_srcu;
1983        }
1984
1985        fs_info->btree_inode = new_inode(sb);
1986        if (!fs_info->btree_inode) {
1987                err = -ENOMEM;
1988                goto fail_bdi;
1989        }
1990
1991        mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
1992
1993        INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
1994        INIT_LIST_HEAD(&fs_info->trans_list);
1995        INIT_LIST_HEAD(&fs_info->dead_roots);
1996        INIT_LIST_HEAD(&fs_info->delayed_iputs);
1997        INIT_LIST_HEAD(&fs_info->hashers);
1998        INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1999        INIT_LIST_HEAD(&fs_info->ordered_operations);
2000        INIT_LIST_HEAD(&fs_info->caching_block_groups);
2001        spin_lock_init(&fs_info->delalloc_lock);
2002        spin_lock_init(&fs_info->trans_lock);
2003        spin_lock_init(&fs_info->ref_cache_lock);
2004        spin_lock_init(&fs_info->fs_roots_radix_lock);
2005        spin_lock_init(&fs_info->delayed_iput_lock);
2006        spin_lock_init(&fs_info->defrag_inodes_lock);
2007        spin_lock_init(&fs_info->free_chunk_lock);
2008        spin_lock_init(&fs_info->tree_mod_seq_lock);
2009        rwlock_init(&fs_info->tree_mod_log_lock);
2010        mutex_init(&fs_info->reloc_mutex);
2011
2012        init_completion(&fs_info->kobj_unregister);
2013        INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2014        INIT_LIST_HEAD(&fs_info->space_info);
2015        INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2016        btrfs_mapping_init(&fs_info->mapping_tree);
2017        btrfs_init_block_rsv(&fs_info->global_block_rsv);
2018        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
2019        btrfs_init_block_rsv(&fs_info->trans_block_rsv);
2020        btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
2021        btrfs_init_block_rsv(&fs_info->empty_block_rsv);
2022        btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
2023        atomic_set(&fs_info->nr_async_submits, 0);
2024        atomic_set(&fs_info->async_delalloc_pages, 0);
2025        atomic_set(&fs_info->async_submit_draining, 0);
2026        atomic_set(&fs_info->nr_async_bios, 0);
2027        atomic_set(&fs_info->defrag_running, 0);
2028        atomic_set(&fs_info->tree_mod_seq, 0);
2029        fs_info->sb = sb;
2030        fs_info->max_inline = 8192 * 1024;
2031        fs_info->metadata_ratio = 0;
2032        fs_info->defrag_inodes = RB_ROOT;
2033        fs_info->trans_no_join = 0;
2034        fs_info->free_chunk_space = 0;
2035        fs_info->tree_mod_log = RB_ROOT;
2036
2037        /* readahead state */
2038        INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
2039        spin_lock_init(&fs_info->reada_lock);
2040
2041        fs_info->thread_pool_size = min_t(unsigned long,
2042                                          num_online_cpus() + 2, 8);
2043
2044        INIT_LIST_HEAD(&fs_info->ordered_extents);
2045        spin_lock_init(&fs_info->ordered_extent_lock);
2046        fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2047                                        GFP_NOFS);
2048        if (!fs_info->delayed_root) {
2049                err = -ENOMEM;
2050                goto fail_iput;
2051        }
2052        btrfs_init_delayed_root(fs_info->delayed_root);
2053
2054        mutex_init(&fs_info->scrub_lock);
2055        atomic_set(&fs_info->scrubs_running, 0);
2056        atomic_set(&fs_info->scrub_pause_req, 0);
2057        atomic_set(&fs_info->scrubs_paused, 0);
2058        atomic_set(&fs_info->scrub_cancel_req, 0);
2059        init_waitqueue_head(&fs_info->scrub_pause_wait);
2060        init_rwsem(&fs_info->scrub_super_lock);
2061        fs_info->scrub_workers_refcnt = 0;
2062#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2063        fs_info->check_integrity_print_mask = 0;
2064#endif
2065
2066        spin_lock_init(&fs_info->balance_lock);
2067        mutex_init(&fs_info->balance_mutex);
2068        atomic_set(&fs_info->balance_running, 0);
2069        atomic_set(&fs_info->balance_pause_req, 0);
2070        atomic_set(&fs_info->balance_cancel_req, 0);
2071        fs_info->balance_ctl = NULL;
2072        init_waitqueue_head(&fs_info->balance_wait_q);
2073
2074        sb->s_blocksize = 4096;
2075        sb->s_blocksize_bits = blksize_bits(4096);
2076        sb->s_bdi = &fs_info->bdi;
2077
2078        fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
2079        set_nlink(fs_info->btree_inode, 1);
2080        /*
2081         * we set the i_size on the btree inode to the max possible int.
2082         * the real end of the address space is determined by all of
2083         * the devices in the system
2084         */
2085        fs_info->btree_inode->i_size = OFFSET_MAX;
2086        fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
2087        fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;
2088
2089        RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2090        extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2091                             fs_info->btree_inode->i_mapping);
2092        BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2093        extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2094
2095        BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2096
2097        BTRFS_I(fs_info->btree_inode)->root = tree_root;
2098        memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
2099               sizeof(struct btrfs_key));
2100        set_bit(BTRFS_INODE_DUMMY,
2101                &BTRFS_I(fs_info->btree_inode)->runtime_flags);
2102        insert_inode_hash(fs_info->btree_inode);
2103
2104        spin_lock_init(&fs_info->block_group_cache_lock);
2105        fs_info->block_group_cache_tree = RB_ROOT;
2106
2107        extent_io_tree_init(&fs_info->freed_extents[0],
2108                             fs_info->btree_inode->i_mapping);
2109        extent_io_tree_init(&fs_info->freed_extents[1],
2110                             fs_info->btree_inode->i_mapping);
2111        fs_info->pinned_extents = &fs_info->freed_extents[0];
2112        fs_info->do_barriers = 1;
2113
2114
2115        mutex_init(&fs_info->ordered_operations_mutex);
2116        mutex_init(&fs_info->tree_log_mutex);
2117        mutex_init(&fs_info->chunk_mutex);
2118        mutex_init(&fs_info->transaction_kthread_mutex);
2119        mutex_init(&fs_info->cleaner_mutex);
2120        mutex_init(&fs_info->volume_mutex);
2121        init_rwsem(&fs_info->extent_commit_sem);
2122        init_rwsem(&fs_info->cleanup_work_sem);
2123        init_rwsem(&fs_info->subvol_sem);
2124
2125        spin_lock_init(&fs_info->qgroup_lock);
2126        fs_info->qgroup_tree = RB_ROOT;
2127        INIT_LIST_HEAD(&fs_info->dirty_qgroups);
2128        fs_info->qgroup_seq = 1;
2129        fs_info->quota_enabled = 0;
2130        fs_info->pending_quota_state = 0;
2131
2132        btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
2133        btrfs_init_free_cluster(&fs_info->data_alloc_cluster);
2134
2135        init_waitqueue_head(&fs_info->transaction_throttle);
2136        init_waitqueue_head(&fs_info->transaction_wait);
2137        init_waitqueue_head(&fs_info->transaction_blocked_wait);
2138        init_waitqueue_head(&fs_info->async_submit_wait);
2139
2140        __setup_root(4096, 4096, 4096, 4096, tree_root,
2141                     fs_info, BTRFS_ROOT_TREE_OBJECTID);
2142
2143        invalidate_bdev(fs_devices->latest_bdev);
2144        bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2145        if (!bh) {
2146                err = -EINVAL;
2147                goto fail_alloc;
2148        }
2149
2150        memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2151        memcpy(fs_info->super_for_commit, fs_info->super_copy,
2152               sizeof(*fs_info->super_for_commit));
2153        brelse(bh);
2154
2155        memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2156
2157        disk_super = fs_info->super_copy;
2158        if (!btrfs_super_root(disk_super))
2159                goto fail_alloc;
2160
2161        /* check FS state, whether FS is broken. */
2162        fs_info->fs_state |= btrfs_super_flags(disk_super);
2163
2164        ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
2165        if (ret) {
2166                printk(KERN_ERR "btrfs: superblock contains fatal errors\n");
2167                err = ret;
2168                goto fail_alloc;
2169        }
2170
2171        /*
2172         * run through our array of backup supers and setup
2173         * our ring pointer to the oldest one
2174         */
2175        generation = btrfs_super_generation(disk_super);
2176        find_oldest_super_backup(fs_info, generation);
2177
2178        /*
2179         * In the long term, we'll store the compression type in the super
2180         * block, and it'll be used for per file compression control.
2181         */
2182        fs_info->compress_type = BTRFS_COMPRESS_ZLIB;
2183
2184        ret = btrfs_parse_options(tree_root, options);
2185        if (ret) {
2186                err = ret;
2187                goto fail_alloc;
2188        }
2189
2190        features = btrfs_super_incompat_flags(disk_super) &
2191                ~BTRFS_FEATURE_INCOMPAT_SUPP;
2192        if (features) {
2193                printk(KERN_ERR "BTRFS: couldn't mount because of "
2194                       "unsupported optional features (%Lx).\n",
2195                       (unsigned long long)features);
2196                err = -EINVAL;
2197                goto fail_alloc;
2198        }
2199
2200        if (btrfs_super_leafsize(disk_super) !=
2201            btrfs_super_nodesize(disk_super)) {
2202                printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2203                       "blocksizes don't match.  node %d leaf %d\n",
2204                       btrfs_super_nodesize(disk_super),
2205                       btrfs_super_leafsize(disk_super));
2206                err = -EINVAL;
2207                goto fail_alloc;
2208        }
2209        if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {
2210                printk(KERN_ERR "BTRFS: couldn't mount because metadata "
2211                       "blocksize (%d) was too large\n",
2212                       btrfs_super_leafsize(disk_super));
2213                err = -EINVAL;
2214                goto fail_alloc;
2215        }
2216
2217        features = btrfs_super_incompat_flags(disk_super);
2218        features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
2219        if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
2220                features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2221
2222        /*
2223         * flag our filesystem as having big metadata blocks if
2224         * they are bigger than the page size
2225         */
2226        if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {
2227                if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2228                        printk(KERN_INFO "btrfs flagging fs with big metadata feature\n");
2229                features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
2230        }
2231
2232        nodesize = btrfs_super_nodesize(disk_super);
2233        leafsize = btrfs_super_leafsize(disk_super);
2234        sectorsize = btrfs_super_sectorsize(disk_super);
2235        stripesize = btrfs_super_stripesize(disk_super);
2236
2237        /*
2238         * mixed block groups end up with duplicate but slightly offset
2239         * extent buffers for the same range.  It leads to corruptions
2240         */
2241        if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
2242            (sectorsize != leafsize)) {
2243                printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes "
2244                                "are not allowed for mixed block groups on %s\n",
2245                                sb->s_id);
2246                goto fail_alloc;
2247        }
2248
2249        btrfs_set_super_incompat_flags(disk_super, features);
2250
2251        features = btrfs_super_compat_ro_flags(disk_super) &
2252                ~BTRFS_FEATURE_COMPAT_RO_SUPP;
2253        if (!(sb->s_flags & MS_RDONLY) && features) {
2254                printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
2255                       "unsupported option features (%Lx).\n",
2256                       (unsigned long long)features);
2257                err = -EINVAL;
2258                goto fail_alloc;
2259        }
2260
2261        btrfs_init_workers(&fs_info->generic_worker,
2262                           "genwork", 1, NULL);
2263
2264        btrfs_init_workers(&fs_info->workers, "worker",
2265                           fs_info->thread_pool_size,
2266                           &fs_info->generic_worker);
2267
2268        btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2269                           fs_info->thread_pool_size,
2270                           &fs_info->generic_worker);
2271
2272        btrfs_init_workers(&fs_info->submit_workers, "submit",
2273                           min_t(u64, fs_devices->num_devices,
2274                           fs_info->thread_pool_size),
2275                           &fs_info->generic_worker);
2276
2277        btrfs_init_workers(&fs_info->caching_workers, "cache",
2278                           2, &fs_info->generic_worker);
2279
2280        /* a higher idle thresh on the submit workers makes it much more
2281         * likely that bios will be send down in a sane order to the
2282         * devices
2283         */
2284        fs_info->submit_workers.idle_thresh = 64;
2285
2286        fs_info->workers.idle_thresh = 16;
2287        fs_info->workers.ordered = 1;
2288
2289        fs_info->delalloc_workers.idle_thresh = 2;
2290        fs_info->delalloc_workers.ordered = 1;
2291
2292        btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
2293                           &fs_info->generic_worker);
2294        btrfs_init_workers(&fs_info->endio_workers, "endio",
2295                           fs_info->thread_pool_size,
2296                           &fs_info->generic_worker);
2297        btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2298                           fs_info->thread_pool_size,
2299                           &fs_info->generic_worker);
2300        btrfs_init_workers(&fs_info->endio_meta_write_workers,
2301                           "endio-meta-write", fs_info->thread_pool_size,
2302                           &fs_info->generic_worker);
2303        btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2304                           fs_info->thread_pool_size,
2305                           &fs_info->generic_worker);
2306        btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
2307                           1, &fs_info->generic_worker);
2308        btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
2309                           fs_info->thread_pool_size,
2310                           &fs_info->generic_worker);
2311        btrfs_init_workers(&fs_info->readahead_workers, "readahead",
2312                           fs_info->thread_pool_size,
2313                           &fs_info->generic_worker);
2314
2315        /*
2316         * endios are largely parallel and should have a very
2317         * low idle thresh
2318         */
2319        fs_info->endio_workers.idle_thresh = 4;
2320        fs_info->endio_meta_workers.idle_thresh = 4;
2321
2322        fs_info->endio_write_workers.idle_thresh = 2;
2323        fs_info->endio_meta_write_workers.idle_thresh = 2;
2324        fs_info->readahead_workers.idle_thresh = 2;
2325
2326        /*
2327         * btrfs_start_workers can really only fail because of ENOMEM so just
2328         * return -ENOMEM if any of these fail.
2329         */
2330        ret = btrfs_start_workers(&fs_info->workers);
2331        ret |= btrfs_start_workers(&fs_info->generic_worker);
2332        ret |= btrfs_start_workers(&fs_info->submit_workers);
2333        ret |= btrfs_start_workers(&fs_info->delalloc_workers);
2334        ret |= btrfs_start_workers(&fs_info->fixup_workers);
2335        ret |= btrfs_start_workers(&fs_info->endio_workers);
2336        ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
2337        ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
2338        ret |= btrfs_start_workers(&fs_info->endio_write_workers);
2339        ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
2340        ret |= btrfs_start_workers(&fs_info->delayed_workers);
2341        ret |= btrfs_start_workers(&fs_info->caching_workers);
2342        ret |= btrfs_start_workers(&fs_info->readahead_workers);
2343        if (ret) {
2344                err = -ENOMEM;
2345                goto fail_sb_buffer;
2346        }
2347
2348        fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
2349        fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
2350                                    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2351
2352        tree_root->nodesize = nodesize;
2353        tree_root->leafsize = leafsize;
2354        tree_root->sectorsize = sectorsize;
2355        tree_root->stripesize = stripesize;
2356
2357        sb->s_blocksize = sectorsize;
2358        sb->s_blocksize_bits = blksize_bits(sectorsize);
2359
2360        if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
2361                    sizeof(disk_super->magic))) {
2362                printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
2363                goto fail_sb_buffer;
2364        }
2365
2366        if (sectorsize != PAGE_SIZE) {
2367                printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
2368                       "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2369                goto fail_sb_buffer;
2370        }
2371
2372        mutex_lock(&fs_info->chunk_mutex);
2373        ret = btrfs_read_sys_array(tree_root);
2374        mutex_unlock(&fs_info->chunk_mutex);
2375        if (ret) {
2376                printk(KERN_WARNING "btrfs: failed to read the system "
2377                       "array on %s\n", sb->s_id);
2378                goto fail_sb_buffer;
2379        }
2380
2381        blocksize = btrfs_level_size(tree_root,
2382                                     btrfs_super_chunk_root_level(disk_super));
2383        generation = btrfs_super_chunk_root_generation(disk_super);
2384
2385        __setup_root(nodesize, leafsize, sectorsize, stripesize,
2386                     chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2387
2388        chunk_root->node = read_tree_block(chunk_root,
2389                                           btrfs_super_chunk_root(disk_super),
2390                                           blocksize, generation);
2391        BUG_ON(!chunk_root->node); /* -ENOMEM */
2392        if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
2393                printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
2394                       sb->s_id);
2395                goto fail_tree_roots;
2396        }
2397        btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
2398        chunk_root->commit_root = btrfs_root_node(chunk_root);
2399
2400        read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2401           (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
2402           BTRFS_UUID_SIZE);
2403
2404        ret = btrfs_read_chunk_tree(chunk_root);
2405        if (ret) {
2406                printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
2407                       sb->s_id);
2408                goto fail_tree_roots;
2409        }
2410
2411        btrfs_close_extra_devices(fs_devices);
2412
2413        if (!fs_devices->latest_bdev) {
2414                printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
2415                       sb->s_id);
2416                goto fail_tree_roots;
2417        }
2418
2419retry_root_backup:
2420        blocksize = btrfs_level_size(tree_root,
2421                                     btrfs_super_root_level(disk_super));
2422        generation = btrfs_super_generation(disk_super);
2423
2424        tree_root->node = read_tree_block(tree_root,
2425                                          btrfs_super_root(disk_super),
2426                                          blocksize, generation);
2427        if (!tree_root->node ||
2428            !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2429                printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
2430                       sb->s_id);
2431
2432                goto recovery_tree_root;
2433        }
2434
2435        btrfs_set_root_node(&tree_root->root_item, tree_root->node);
2436        tree_root->commit_root = btrfs_root_node(tree_root);
2437
2438        ret = find_and_setup_root(tree_root, fs_info,
2439                                  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
2440        if (ret)
2441                goto recovery_tree_root;
2442        extent_root->track_dirty = 1;
2443
2444        ret = find_and_setup_root(tree_root, fs_info,
2445                                  BTRFS_DEV_TREE_OBJECTID, dev_root);
2446        if (ret)
2447                goto recovery_tree_root;
2448        dev_root->track_dirty = 1;
2449
2450        ret = find_and_setup_root(tree_root, fs_info,
2451                                  BTRFS_CSUM_TREE_OBJECTID, csum_root);
2452        if (ret)
2453                goto recovery_tree_root;
2454        csum_root->track_dirty = 1;
2455
2456        ret = find_and_setup_root(tree_root, fs_info,
2457                                  BTRFS_QUOTA_TREE_OBJECTID, quota_root);
2458        if (ret) {
2459                kfree(quota_root);
2460                quota_root = fs_info->quota_root = NULL;
2461        } else {
2462                quota_root->track_dirty = 1;
2463                fs_info->quota_enabled = 1;
2464                fs_info->pending_quota_state = 1;
2465        }
2466
2467        fs_info->generation = generation;
2468        fs_info->last_trans_committed = generation;
2469
2470        ret = btrfs_recover_balance(fs_info);
2471        if (ret) {
2472                printk(KERN_WARNING "btrfs: failed to recover balance\n");
2473                goto fail_block_groups;
2474        }
2475
2476        ret = btrfs_init_dev_stats(fs_info);
2477        if (ret) {
2478                printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
2479                       ret);
2480                goto fail_block_groups;
2481        }
2482
2483        ret = btrfs_init_space_info(fs_info);
2484        if (ret) {
2485                printk(KERN_ERR "Failed to initial space info: %d\n", ret);
2486                goto fail_block_groups;
2487        }
2488
2489        ret = btrfs_read_block_groups(extent_root);
2490        if (ret) {
2491                printk(KERN_ERR "Failed to read block groups: %d\n", ret);
2492                goto fail_block_groups;
2493        }
2494
2495        fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
2496                                               "btrfs-cleaner");
2497        if (IS_ERR(fs_info->cleaner_kthread))
2498                goto fail_block_groups;
2499
2500        fs_info->transaction_kthread = kthread_run(transaction_kthread,
2501                                                   tree_root,
2502                                                   "btrfs-transaction");
2503        if (IS_ERR(fs_info->transaction_kthread))
2504                goto fail_cleaner;
2505
2506        if (!btrfs_test_opt(tree_root, SSD) &&
2507            !btrfs_test_opt(tree_root, NOSSD) &&
2508            !fs_info->fs_devices->rotating) {
2509                printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
2510                       "mode\n");
2511                btrfs_set_opt(fs_info->mount_opt, SSD);
2512        }
2513
2514#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2515        if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
2516                ret = btrfsic_mount(tree_root, fs_devices,
2517                                    btrfs_test_opt(tree_root,
2518                                        CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
2519                                    1 : 0,
2520                                    fs_info->check_integrity_print_mask);
2521                if (ret)
2522                        printk(KERN_WARNING "btrfs: failed to initialize"
2523                               " integrity check module %s\n", sb->s_id);
2524        }
2525#endif
2526        ret = btrfs_read_qgroup_config(fs_info);
2527        if (ret)
2528                goto fail_trans_kthread;
2529
2530        /* do not make disk changes in broken FS */
2531        if (btrfs_super_log_root(disk_super) != 0) {
2532                u64 bytenr = btrfs_super_log_root(disk_super);
2533
2534                if (fs_devices->rw_devices == 0) {
2535                        printk(KERN_WARNING "Btrfs log replay required "
2536                               "on RO media\n");
2537                        err = -EIO;
2538                        goto fail_qgroup;
2539                }
2540                blocksize =
2541                     btrfs_level_size(tree_root,
2542                                      btrfs_super_log_root_level(disk_super));
2543
2544                log_tree_root = btrfs_alloc_root(fs_info);
2545                if (!log_tree_root) {
2546                        err = -ENOMEM;
2547                        goto fail_qgroup;
2548                }
2549
2550                __setup_root(nodesize, leafsize, sectorsize, stripesize,
2551                             log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
2552
2553                log_tree_root->node = read_tree_block(tree_root, bytenr,
2554                                                      blocksize,
2555                                                      generation + 1);
2556                /* returns with log_tree_root freed on success */
2557                ret = btrfs_recover_log_trees(log_tree_root);
2558                if (ret) {
2559                        btrfs_error(tree_root->fs_info, ret,
2560                                    "Failed to recover log tree");
2561                        free_extent_buffer(log_tree_root->node);
2562                        kfree(log_tree_root);
2563                        goto fail_trans_kthread;
2564                }
2565
2566                if (sb->s_flags & MS_RDONLY) {
2567                        ret = btrfs_commit_super(tree_root);
2568                        if (ret)
2569                                goto fail_trans_kthread;
2570                }
2571        }
2572
2573        ret = btrfs_find_orphan_roots(tree_root);
2574        if (ret)
2575                goto fail_trans_kthread;
2576
2577        if (!(sb->s_flags & MS_RDONLY)) {
2578                ret = btrfs_cleanup_fs_roots(fs_info);
2579                if (ret)
2580                        goto fail_trans_kthread;
2581
2582                ret = btrfs_recover_relocation(tree_root);
2583                if (ret < 0) {
2584                        printk(KERN_WARNING
2585                               "btrfs: failed to recover relocation\n");
2586                        err = -EINVAL;
2587                        goto fail_qgroup;
2588                }
2589        }
2590
2591        location.objectid = BTRFS_FS_TREE_OBJECTID;
2592        location.type = BTRFS_ROOT_ITEM_KEY;
2593        location.offset = (u64)-1;
2594
2595        fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2596        if (!fs_info->fs_root)
2597                goto fail_qgroup;
2598        if (IS_ERR(fs_info->fs_root)) {
2599                err = PTR_ERR(fs_info->fs_root);
2600                goto fail_qgroup;
2601        }
2602
2603        if (sb->s_flags & MS_RDONLY)
2604                return 0;
2605
2606        down_read(&fs_info->cleanup_work_sem);
2607        if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
2608            (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2609                up_read(&fs_info->cleanup_work_sem);
2610                close_ctree(tree_root);
2611                return ret;
2612        }
2613        up_read(&fs_info->cleanup_work_sem);
2614
2615        ret = btrfs_resume_balance_async(fs_info);
2616        if (ret) {
2617                printk(KERN_WARNING "btrfs: failed to resume balance\n");
2618                close_ctree(tree_root);
2619                return ret;
2620        }
2621
2622        return 0;
2623
2624fail_qgroup:
2625        btrfs_free_qgroup_config(fs_info);
2626fail_trans_kthread:
2627        kthread_stop(fs_info->transaction_kthread);
2628fail_cleaner:
2629        kthread_stop(fs_info->cleaner_kthread);
2630
2631        /*
2632         * make sure we're done with the btree inode before we stop our
2633         * kthreads
2634         */
2635        filemap_write_and_wait(fs_info->btree_inode->i_mapping);
2636        invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2637
2638fail_block_groups:
2639        btrfs_free_block_groups(fs_info);
2640
2641fail_tree_roots:
2642        free_root_pointers(fs_info, 1);
2643
2644fail_sb_buffer:
2645        btrfs_stop_workers(&fs_info->generic_worker);
2646        btrfs_stop_workers(&fs_info->readahead_workers);
2647        btrfs_stop_workers(&fs_info->fixup_workers);
2648        btrfs_stop_workers(&fs_info->delalloc_workers);
2649        btrfs_stop_workers(&fs_info->workers);
2650        btrfs_stop_workers(&fs_info->endio_workers);
2651        btrfs_stop_workers(&fs_info->endio_meta_workers);
2652        btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2653        btrfs_stop_workers(&fs_info->endio_write_workers);
2654        btrfs_stop_workers(&fs_info->endio_freespace_worker);
2655        btrfs_stop_workers(&fs_info->submit_workers);
2656        btrfs_stop_workers(&fs_info->delayed_workers);
2657        btrfs_stop_workers(&fs_info->caching_workers);
2658fail_alloc:
2659fail_iput:
2660        btrfs_mapping_tree_free(&fs_info->mapping_tree);
2661
2662        invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2663        iput(fs_info->btree_inode);
2664fail_bdi:
2665        bdi_destroy(&fs_info->bdi);
2666fail_srcu:
2667        cleanup_srcu_struct(&fs_info->subvol_srcu);
2668fail:
2669        btrfs_close_devices(fs_info->fs_devices);
2670        return err;
2671
2672recovery_tree_root:
2673        if (!btrfs_test_opt(tree_root, RECOVERY))
2674                goto fail_tree_roots;
2675
2676        free_root_pointers(fs_info, 0);
2677
2678        /* don't use the log in recovery mode, it won't be valid */
2679        btrfs_set_super_log_root(disk_super, 0);
2680
2681        /* we can't trust the free space cache either */
2682        btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);
2683
2684        ret = next_root_backup(fs_info, fs_info->super_copy,
2685                               &num_backups_tried, &backup_index);
2686        if (ret == -1)
2687                goto fail_block_groups;
2688        goto retry_root_backup;
2689}
2690
2691static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
2692{
2693        if (uptodate) {
2694                set_buffer_uptodate(bh);
2695        } else {
2696                struct btrfs_device *device = (struct btrfs_device *)
2697                        bh->b_private;
2698
2699                printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
2700                                          "I/O error on %s\n",
2701                                          rcu_str_deref(device->name));
2702                /* note, we dont' set_buffer_write_io_error because we have
2703                 * our own ways of dealing with the IO errors
2704                 */
2705                clear_buffer_uptodate(bh);
2706                btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
2707        }
2708        unlock_buffer(bh);
2709        put_bh(bh);
2710}
2711
2712struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
2713{
2714        struct buffer_head *bh;
2715        struct buffer_head *latest = NULL;
2716        struct btrfs_super_block *super;
2717        int i;
2718        u64 transid = 0;
2719        u64 bytenr;
2720
2721        /* we would like to check all the supers, but that would make
2722         * a btrfs mount succeed after a mkfs from a different FS.
2723         * So, we need to add a special mount option to scan for
2724         * later supers, using BTRFS_SUPER_MIRROR_MAX instead
2725         */
2726        for (i = 0; i < 1; i++) {
2727                bytenr = btrfs_sb_offset(i);
2728                if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
2729                        break;
2730                bh = __bread(bdev, bytenr / 4096, 4096);
2731                if (!bh)
2732                        continue;
2733
2734                super = (struct btrfs_super_block *)bh->b_data;
2735                if (btrfs_super_bytenr(super) != bytenr ||
2736                    strncmp((char *)(&super->magic), BTRFS_MAGIC,
2737                            sizeof(super->magic))) {
2738                        brelse(bh);
2739                        continue;
2740                }
2741
2742                if (!latest || btrfs_super_generation(super) > transid) {
2743                        brelse(latest);
2744                        latest = bh;
2745                        transid = btrfs_super_generation(super);
2746                } else {
2747                        brelse(bh);
2748                }
2749        }
2750        return latest;
2751}
2752
2753/*
2754 * this should be called twice, once with wait == 0 and
2755 * once with wait == 1.  When wait == 0 is done, all the buffer heads
2756 * we write are pinned.
2757 *
2758 * They are released when wait == 1 is done.
2759 * max_mirrors must be the same for both runs, and it indicates how
2760 * many supers on this one device should be written.
2761 *
2762 * max_mirrors == 0 means to write them all.
2763 */
2764static int write_dev_supers(struct btrfs_device *device,
2765                            struct btrfs_super_block *sb,
2766                            int do_barriers, int wait, int max_mirrors)
2767{
2768        struct buffer_head *bh;
2769        int i;
2770        int ret;
2771        int errors = 0;
2772        u32 crc;
2773        u64 bytenr;
2774
2775        if (max_mirrors == 0)
2776                max_mirrors = BTRFS_SUPER_MIRROR_MAX;
2777
2778        for (i = 0; i < max_mirrors; i++) {
2779                bytenr = btrfs_sb_offset(i);
2780                if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
2781                        break;
2782
2783                if (wait) {
2784                        bh = __find_get_block(device->bdev, bytenr / 4096,
2785                                              BTRFS_SUPER_INFO_SIZE);
2786                        BUG_ON(!bh);
2787                        wait_on_buffer(bh);
2788                        if (!buffer_uptodate(bh))
2789                                errors++;
2790
2791                        /* drop our reference */
2792                        brelse(bh);
2793
2794                        /* drop the reference from the wait == 0 run */
2795                        brelse(bh);
2796                        continue;
2797                } else {
2798                        btrfs_set_super_bytenr(sb, bytenr);
2799
2800                        crc = ~(u32)0;
2801                        crc = btrfs_csum_data(NULL, (char *)sb +
2802                                              BTRFS_CSUM_SIZE, crc,
2803                                              BTRFS_SUPER_INFO_SIZE -
2804                                              BTRFS_CSUM_SIZE);
2805                        btrfs_csum_final(crc, sb->csum);
2806
2807                        /*
2808                         * one reference for us, and we leave it for the
2809                         * caller
2810                         */
2811                        bh = __getblk(device->bdev, bytenr / 4096,
2812                                      BTRFS_SUPER_INFO_SIZE);
2813                        memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
2814
2815                        /* one reference for submit_bh */
2816                        get_bh(bh);
2817
2818                        set_buffer_uptodate(bh);
2819                        lock_buffer(bh);
2820                        bh->b_end_io = btrfs_end_buffer_write_sync;
2821                        bh->b_private = device;
2822                }
2823
2824                /*
2825                 * we fua the first super.  The others we allow
2826                 * to go down lazy.
2827                 */
2828                ret = btrfsic_submit_bh(WRITE_FUA, bh);
2829                if (ret)
2830                        errors++;
2831        }
2832        return errors < i ? 0 : -1;
2833}
2834
2835/*
2836 * endio for the write_dev_flush, this will wake anyone waiting
2837 * for the barrier when it is done
2838 */
2839static void btrfs_end_empty_barrier(struct bio *bio, int err)
2840{
2841        if (err) {
2842                if (err == -EOPNOTSUPP)
2843                        set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
2844                clear_bit(BIO_UPTODATE, &bio->bi_flags);
2845        }
2846        if (bio->bi_private)
2847                complete(bio->bi_private);
2848        bio_put(bio);
2849}
2850
2851/*
2852 * trigger flushes for one the devices.  If you pass wait == 0, the flushes are
2853 * sent down.  With wait == 1, it waits for the previous flush.
2854 *
2855 * any device where the flush fails with eopnotsupp are flagged as not-barrier
2856 * capable
2857 */
2858static int write_dev_flush(struct btrfs_device *device, int wait)
2859{
2860        struct bio *bio;
2861        int ret = 0;
2862
2863        if (device->nobarriers)
2864                return 0;
2865
2866        if (wait) {
2867                bio = device->flush_bio;
2868                if (!bio)
2869                        return 0;
2870
2871                wait_for_completion(&device->flush_wait);
2872
2873                if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
2874                        printk_in_rcu("btrfs: disabling barriers on dev %s\n",
2875                                      rcu_str_deref(device->name));
2876                        device->nobarriers = 1;
2877                }
2878                if (!bio_flagged(bio, BIO_UPTODATE)) {
2879                        ret = -EIO;
2880                        if (!bio_flagged(bio, BIO_EOPNOTSUPP))
2881                                btrfs_dev_stat_inc_and_print(device,
2882                                        BTRFS_DEV_STAT_FLUSH_ERRS);
2883                }
2884
2885                /* drop the reference from the wait == 0 run */
2886                bio_put(bio);
2887                device->flush_bio = NULL;
2888
2889                return ret;
2890        }
2891
2892        /*
2893         * one reference for us, and we leave it for the
2894         * caller
2895         */
2896        device->flush_bio = NULL;
2897        bio = bio_alloc(GFP_NOFS, 0);
2898        if (!bio)
2899                return -ENOMEM;
2900
2901        bio->bi_end_io = btrfs_end_empty_barrier;
2902        bio->bi_bdev = device->bdev;
2903        init_completion(&device->flush_wait);
2904        bio->bi_private = &device->flush_wait;
2905        device->flush_bio = bio;
2906
2907        bio_get(bio);
2908        btrfsic_submit_bio(WRITE_FLUSH, bio);
2909
2910        return 0;
2911}
2912
2913/*
2914 * send an empty flush down to each device in parallel,
2915 * then wait for them
2916 */
2917static int barrier_all_devices(struct btrfs_fs_info *info)
2918{
2919        struct list_head *head;
2920        struct btrfs_device *dev;
2921        int errors = 0;
2922        int ret;
2923
2924        /* send down all the barriers */
2925        head = &info->fs_devices->devices;
2926        list_for_each_entry_rcu(dev, head, dev_list) {
2927                if (!dev->bdev) {
2928                        errors++;
2929                        continue;
2930                }
2931                if (!dev->in_fs_metadata || !dev->writeable)
2932                        continue;
2933
2934                ret = write_dev_flush(dev, 0);
2935                if (ret)
2936                        errors++;
2937        }
2938
2939        /* wait for all the barriers */
2940        list_for_each_entry_rcu(dev, head, dev_list) {
2941                if (!dev->bdev) {
2942                        errors++;
2943                        continue;
2944                }
2945                if (!dev->in_fs_metadata || !dev->writeable)
2946                        continue;
2947
2948                ret = write_dev_flush(dev, 1);
2949                if (ret)
2950                        errors++;
2951        }
2952        if (errors)
2953                return -EIO;
2954        return 0;
2955}
2956
2957int write_all_supers(struct btrfs_root *root, int max_mirrors)
2958{
2959        struct list_head *head;
2960        struct btrfs_device *dev;
2961        struct btrfs_super_block *sb;
2962        struct btrfs_dev_item *dev_item;
2963        int ret;
2964        int do_barriers;
2965        int max_errors;
2966        int total_errors = 0;
2967        u64 flags;
2968
2969        max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
2970        do_barriers = !btrfs_test_opt(root, NOBARRIER);
2971        backup_super_roots(root->fs_info);
2972
2973        sb = root->fs_info->super_for_commit;
2974        dev_item = &sb->dev_item;
2975
2976        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2977        head = &root->fs_info->fs_devices->devices;
2978
2979        if (do_barriers)
2980                barrier_all_devices(root->fs_info);
2981
2982        list_for_each_entry_rcu(dev, head, dev_list) {
2983                if (!dev->bdev) {
2984                        total_errors++;
2985                        continue;
2986                }
2987                if (!dev->in_fs_metadata || !dev->writeable)
2988                        continue;
2989
2990                btrfs_set_stack_device_generation(dev_item, 0);
2991                btrfs_set_stack_device_type(dev_item, dev->type);
2992                btrfs_set_stack_device_id(dev_item, dev->devid);
2993                btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
2994                btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
2995                btrfs_set_stack_device_io_align(dev_item, dev->io_align);
2996                btrfs_set_stack_device_io_width(dev_item, dev->io_width);
2997                btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
2998                memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
2999                memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
3000
3001                flags = btrfs_super_flags(sb);
3002                btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);
3003
3004                ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3005                if (ret)
3006                        total_errors++;
3007        }
3008        if (total_errors > max_errors) {
3009                printk(KERN_ERR "btrfs: %d errors while writing supers\n",
3010                       total_errors);
3011
3012                /* This shouldn't happen. FUA is masked off if unsupported */
3013                BUG();
3014        }
3015
3016        total_errors = 0;
3017        list_for_each_entry_rcu(dev, head, dev_list) {
3018                if (!dev->bdev)
3019                        continue;
3020                if (!dev->in_fs_metadata || !dev->writeable)
3021                        continue;
3022
3023                ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
3024                if (ret)
3025                        total_errors++;
3026        }
3027        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3028        if (total_errors > max_errors) {
3029                btrfs_error(root->fs_info, -EIO,
3030                            "%d errors while writing supers", total_errors);
3031                return -EIO;
3032        }
3033        return 0;
3034}
3035
3036int write_ctree_super(struct btrfs_trans_handle *trans,
3037                      struct btrfs_root *root, int max_mirrors)
3038{
3039        int ret;
3040
3041        ret = write_all_supers(root, max_mirrors);
3042        return ret;
3043}
3044
3045void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
3046{
3047        spin_lock(&fs_info->fs_roots_radix_lock);
3048        radix_tree_delete(&fs_info->fs_roots_radix,
3049                          (unsigned long)root->root_key.objectid);
3050        spin_unlock(&fs_info->fs_roots_radix_lock);
3051
3052        if (btrfs_root_refs(&root->root_item) == 0)
3053                synchronize_srcu(&fs_info->subvol_srcu);
3054
3055        __btrfs_remove_free_space_cache(root->free_ino_pinned);
3056        __btrfs_remove_free_space_cache(root->free_ino_ctl);
3057        free_fs_root(root);
3058}
3059
3060static void free_fs_root(struct btrfs_root *root)
3061{
3062        iput(root->cache_inode);
3063        WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3064        if (root->anon_dev)
3065                free_anon_bdev(root->anon_dev);
3066        free_extent_buffer(root->node);
3067        free_extent_buffer(root->commit_root);
3068        kfree(root->free_ino_ctl);
3069        kfree(root->free_ino_pinned);
3070        kfree(root->name);
3071        kfree(root);
3072}
3073
3074static void del_fs_roots(struct btrfs_fs_info *fs_info)
3075{
3076        int ret;
3077        struct btrfs_root *gang[8];
3078        int i;
3079
3080        while (!list_empty(&fs_info->dead_roots)) {
3081                gang[0] = list_entry(fs_info->dead_roots.next,
3082                                     struct btrfs_root, root_list);
3083                list_del(&gang[0]->root_list);
3084
3085                if (gang[0]->in_radix) {
3086                        btrfs_free_fs_root(fs_info, gang[0]);
3087                } else {
3088                        free_extent_buffer(gang[0]->node);
3089                        free_extent_buffer(gang[0]->commit_root);
3090                        kfree(gang[0]);
3091                }
3092        }
3093
3094        while (1) {
3095                ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3096                                             (void **)gang, 0,
3097                                             ARRAY_SIZE(gang));
3098                if (!ret)
3099                        break;
3100                for (i = 0; i < ret; i++)
3101                        btrfs_free_fs_root(fs_info, gang[i]);
3102        }
3103}
3104
3105int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
3106{
3107        u64 root_objectid = 0;
3108        struct btrfs_root *gang[8];
3109        int i;
3110        int ret;
3111
3112        while (1) {
3113                ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
3114                                             (void **)gang, root_objectid,
3115                                             ARRAY_SIZE(gang));
3116                if (!ret)
3117                        break;
3118
3119                root_objectid = gang[ret - 1]->root_key.objectid + 1;
3120                for (i = 0; i < ret; i++) {
3121                        int err;
3122
3123                        root_objectid = gang[i]->root_key.objectid;
3124                        err = btrfs_orphan_cleanup(gang[i]);
3125                        if (err)
3126                                return err;
3127                }
3128                root_objectid++;
3129        }
3130        return 0;
3131}
3132
3133int btrfs_commit_super(struct btrfs_root *root)
3134{
3135        struct btrfs_trans_handle *trans;
3136        int ret;
3137
3138        mutex_lock(&root->fs_info->cleaner_mutex);
3139        btrfs_run_delayed_iputs(root);
3140        btrfs_clean_old_snapshots(root);
3141        mutex_unlock(&root->fs_info->cleaner_mutex);
3142
3143        /* wait until ongoing cleanup work done */
3144        down_write(&root->fs_info->cleanup_work_sem);
3145        up_write(&root->fs_info->cleanup_work_sem);
3146
3147        trans = btrfs_join_transaction(root);
3148        if (IS_ERR(trans))
3149                return PTR_ERR(trans);
3150        ret = btrfs_commit_transaction(trans, root);
3151        if (ret)
3152                return ret;
3153        /* run commit again to drop the original snapshot */
3154        trans = btrfs_join_transaction(root);
3155        if (IS_ERR(trans))
3156                return PTR_ERR(trans);
3157        ret = btrfs_commit_transaction(trans, root);
3158        if (ret)
3159                return ret;
3160        ret = btrfs_write_and_wait_transaction(NULL, root);
3161        if (ret) {
3162                btrfs_error(root->fs_info, ret,
3163                            "Failed to sync btree inode to disk.");
3164                return ret;
3165        }
3166
3167        ret = write_ctree_super(NULL, root, 0);
3168        return ret;
3169}
3170
3171int close_ctree(struct btrfs_root *root)
3172{
3173        struct btrfs_fs_info *fs_info = root->fs_info;
3174        int ret;
3175
3176        fs_info->closing = 1;
3177        smp_mb();
3178
3179        /* pause restriper - we want to resume on mount */
3180        btrfs_pause_balance(root->fs_info);
3181
3182        btrfs_scrub_cancel(root);
3183
3184        /* wait for any defraggers to finish */
3185        wait_event(fs_info->transaction_wait,
3186                   (atomic_read(&fs_info->defrag_running) == 0));
3187
3188        /* clear out the rbtree of defraggable inodes */
3189        btrfs_run_defrag_inodes(fs_info);
3190
3191        if (!(fs_info->sb->s_flags & MS_RDONLY)) {
3192                ret = btrfs_commit_super(root);
3193                if (ret)
3194                        printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
3195        }
3196
3197        if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
3198                btrfs_error_commit_super(root);
3199
3200        btrfs_put_block_group_cache(fs_info);
3201
3202        kthread_stop(fs_info->transaction_kthread);
3203        kthread_stop(fs_info->cleaner_kthread);
3204
3205        fs_info->closing = 2;
3206        smp_mb();
3207
3208        btrfs_free_qgroup_config(root->fs_info);
3209
3210        if (fs_info->delalloc_bytes) {
3211                printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
3212                       (unsigned long long)fs_info->delalloc_bytes);
3213        }
3214        if (fs_info->total_ref_cache_size) {
3215                printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
3216                       (unsigned long long)fs_info->total_ref_cache_size);
3217        }
3218
3219        free_extent_buffer(fs_info->extent_root->node);
3220        free_extent_buffer(fs_info->extent_root->commit_root);
3221        free_extent_buffer(fs_info->tree_root->node);
3222        free_extent_buffer(fs_info->tree_root->commit_root);
3223        free_extent_buffer(fs_info->chunk_root->node);
3224        free_extent_buffer(fs_info->chunk_root->commit_root);
3225        free_extent_buffer(fs_info->dev_root->node);
3226        free_extent_buffer(fs_info->dev_root->commit_root);
3227        free_extent_buffer(fs_info->csum_root->node);
3228        free_extent_buffer(fs_info->csum_root->commit_root);
3229        if (fs_info->quota_root) {
3230                free_extent_buffer(fs_info->quota_root->node);
3231                free_extent_buffer(fs_info->quota_root->commit_root);
3232        }
3233
3234        btrfs_free_block_groups(fs_info);
3235
3236        del_fs_roots(fs_info);
3237
3238        iput(fs_info->btree_inode);
3239
3240        btrfs_stop_workers(&fs_info->generic_worker);
3241        btrfs_stop_workers(&fs_info->fixup_workers);
3242        btrfs_stop_workers(&fs_info->delalloc_workers);
3243        btrfs_stop_workers(&fs_info->workers);
3244        btrfs_stop_workers(&fs_info->endio_workers);
3245        btrfs_stop_workers(&fs_info->endio_meta_workers);
3246        btrfs_stop_workers(&fs_info->endio_meta_write_workers);
3247        btrfs_stop_workers(&fs_info->endio_write_workers);
3248        btrfs_stop_workers(&fs_info->endio_freespace_worker);
3249        btrfs_stop_workers(&fs_info->submit_workers);
3250        btrfs_stop_workers(&fs_info->delayed_workers);
3251        btrfs_stop_workers(&fs_info->caching_workers);
3252        btrfs_stop_workers(&fs_info->readahead_workers);
3253
3254#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3255        if (btrfs_test_opt(root, CHECK_INTEGRITY))
3256                btrfsic_unmount(root, fs_info->fs_devices);
3257#endif
3258
3259        btrfs_close_devices(fs_info->fs_devices);
3260        btrfs_mapping_tree_free(&fs_info->mapping_tree);
3261
3262        bdi_destroy(&fs_info->bdi);
3263        cleanup_srcu_struct(&fs_info->subvol_srcu);
3264
3265        return 0;
3266}
3267
3268int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
3269                          int atomic)
3270{
3271        int ret;
3272        struct inode *btree_inode = buf->pages[0]->mapping->host;
3273
3274        ret = extent_buffer_uptodate(buf);
3275        if (!ret)
3276                return ret;
3277
3278        ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3279                                    parent_transid, atomic);
3280        if (ret == -EAGAIN)
3281                return ret;
3282        return !ret;
3283}
3284
3285int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
3286{
3287        return set_extent_buffer_uptodate(buf);
3288}
3289
3290void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
3291{
3292        struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3293        u64 transid = btrfs_header_generation(buf);
3294        int was_dirty;
3295
3296        btrfs_assert_tree_locked(buf);
3297        if (transid != root->fs_info->generation) {
3298                printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
3299                       "found %llu running %llu\n",
3300                        (unsigned long long)buf->start,
3301                        (unsigned long long)transid,
3302                        (unsigned long long)root->fs_info->generation);
3303                WARN_ON(1);
3304        }
3305        was_dirty = set_extent_buffer_dirty(buf);
3306        if (!was_dirty) {
3307                spin_lock(&root->fs_info->delalloc_lock);
3308                root->fs_info->dirty_metadata_bytes += buf->len;
3309                spin_unlock(&root->fs_info->delalloc_lock);
3310        }
3311}
3312
3313void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
3314{
3315        /*
3316         * looks as though older kernels can get into trouble with
3317         * this code, they end up stuck in balance_dirty_pages forever
3318         */
3319        u64 num_dirty;
3320        unsigned long thresh = 32 * 1024 * 1024;
3321
3322        if (current->flags & PF_MEMALLOC)
3323                return;
3324
3325        btrfs_balance_delayed_items(root);
3326
3327        num_dirty = root->fs_info->dirty_metadata_bytes;
3328
3329        if (num_dirty > thresh) {
3330                balance_dirty_pages_ratelimited_nr(
3331                                   root->fs_info->btree_inode->i_mapping, 1);
3332        }
3333        return;
3334}
3335
3336void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
3337{
3338        /*
3339         * looks as though older kernels can get into trouble with
3340         * this code, they end up stuck in balance_dirty_pages forever
3341         */
3342        u64 num_dirty;
3343        unsigned long thresh = 32 * 1024 * 1024;
3344
3345        if (current->flags & PF_MEMALLOC)
3346                return;
3347
3348        num_dirty = root->fs_info->dirty_metadata_bytes;
3349
3350        if (num_dirty > thresh) {
3351                balance_dirty_pages_ratelimited_nr(
3352                                   root->fs_info->btree_inode->i_mapping, 1);
3353        }
3354        return;
3355}
3356
3357int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3358{
3359        struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3360        return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3361}
3362
3363int btree_lock_page_hook(struct page *page, void *data,
3364                                void (*flush_fn)(void *))
3365{
3366        struct inode *inode = page->mapping->host;
3367        struct btrfs_root *root = BTRFS_I(inode)->root;
3368        struct extent_buffer *eb;
3369
3370        /*
3371         * We culled this eb but the page is still hanging out on the mapping,
3372         * carry on.
3373         */
3374        if (!PagePrivate(page))
3375                goto out;
3376
3377        eb = (struct extent_buffer *)page->private;
3378        if (!eb) {
3379                WARN_ON(1);
3380                goto out;
3381        }
3382        if (page != eb->pages[0])
3383                goto out;
3384
3385        if (!btrfs_try_tree_write_lock(eb)) {
3386                flush_fn(data);
3387                btrfs_tree_lock(eb);
3388        }
3389        btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
3390
3391        if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
3392                spin_lock(&root->fs_info->delalloc_lock);
3393                if (root->fs_info->dirty_metadata_bytes >= eb->len)
3394                        root->fs_info->dirty_metadata_bytes -= eb->len;
3395                else
3396                        WARN_ON(1);
3397                spin_unlock(&root->fs_info->delalloc_lock);
3398        }
3399
3400        btrfs_tree_unlock(eb);
3401out:
3402        if (!trylock_page(page)) {
3403                flush_fn(data);
3404                lock_page(page);
3405        }
3406        return 0;
3407}
3408
3409static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
3410                              int read_only)
3411{
3412        if (btrfs_super_csum_type(fs_info->super_copy) >= ARRAY_SIZE(btrfs_csum_sizes)) {
3413                printk(KERN_ERR "btrfs: unsupported checksum algorithm\n");
3414                return -EINVAL;
3415        }
3416
3417        if (read_only)
3418                return 0;
3419
3420        return 0;
3421}
3422
3423void btrfs_error_commit_super(struct btrfs_root *root)
3424{
3425        mutex_lock(&root->fs_info->cleaner_mutex);
3426        btrfs_run_delayed_iputs(root);
3427        mutex_unlock(&root->fs_info->cleaner_mutex);
3428
3429        down_write(&root->fs_info->cleanup_work_sem);
3430        up_write(&root->fs_info->cleanup_work_sem);
3431
3432        /* cleanup FS via transaction */
3433        btrfs_cleanup_transaction(root);
3434}
3435
3436static void btrfs_destroy_ordered_operations(struct btrfs_root *root)
3437{
3438        struct btrfs_inode *btrfs_inode;
3439        struct list_head splice;
3440
3441        INIT_LIST_HEAD(&splice);
3442
3443        mutex_lock(&root->fs_info->ordered_operations_mutex);
3444        spin_lock(&root->fs_info->ordered_extent_lock);
3445
3446        list_splice_init(&root->fs_info->ordered_operations, &splice);
3447        while (!list_empty(&splice)) {
3448                btrfs_inode = list_entry(splice.next, struct btrfs_inode,
3449                                         ordered_operations);
3450
3451                list_del_init(&btrfs_inode->ordered_operations);
3452
3453                btrfs_invalidate_inodes(btrfs_inode->root);
3454        }
3455
3456        spin_unlock(&root->fs_info->ordered_extent_lock);
3457        mutex_unlock(&root->fs_info->ordered_operations_mutex);
3458}
3459
3460static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
3461{
3462        struct list_head splice;
3463        struct btrfs_ordered_extent *ordered;
3464        struct inode *inode;
3465
3466        INIT_LIST_HEAD(&splice);
3467
3468        spin_lock(&root->fs_info->ordered_extent_lock);
3469
3470        list_splice_init(&root->fs_info->ordered_extents, &splice);
3471        while (!list_empty(&splice)) {
3472                ordered = list_entry(splice.next, struct btrfs_ordered_extent,
3473                                     root_extent_list);
3474
3475                list_del_init(&ordered->root_extent_list);
3476                atomic_inc(&ordered->refs);
3477
3478                /* the inode may be getting freed (in sys_unlink path). */
3479                inode = igrab(ordered->inode);
3480
3481                spin_unlock(&root->fs_info->ordered_extent_lock);
3482                if (inode)
3483                        iput(inode);
3484
3485                atomic_set(&ordered->refs, 1);
3486                btrfs_put_ordered_extent(ordered);
3487
3488                spin_lock(&root->fs_info->ordered_extent_lock);
3489        }
3490
3491        spin_unlock(&root->fs_info->ordered_extent_lock);
3492}
3493
3494int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
3495                               struct btrfs_root *root)
3496{
3497        struct rb_node *node;
3498        struct btrfs_delayed_ref_root *delayed_refs;
3499        struct btrfs_delayed_ref_node *ref;
3500        int ret = 0;
3501
3502        delayed_refs = &trans->delayed_refs;
3503
3504        spin_lock(&delayed_refs->lock);
3505        if (delayed_refs->num_entries == 0) {
3506                spin_unlock(&delayed_refs->lock);
3507                printk(KERN_INFO "delayed_refs has NO entry\n");
3508                return ret;
3509        }
3510
3511        while ((node = rb_first(&delayed_refs->root)) != NULL) {
3512                ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
3513
3514                atomic_set(&ref->refs, 1);
3515                if (btrfs_delayed_ref_is_head(ref)) {
3516                        struct btrfs_delayed_ref_head *head;
3517
3518                        head = btrfs_delayed_node_to_head(ref);
3519                        if (!mutex_trylock(&head->mutex)) {
3520                                atomic_inc(&ref->refs);
3521                                spin_unlock(&delayed_refs->lock);
3522
3523                                /* Need to wait for the delayed ref to run */
3524                                mutex_lock(&head->mutex);
3525                                mutex_unlock(&head->mutex);
3526                                btrfs_put_delayed_ref(ref);
3527
3528                                spin_lock(&delayed_refs->lock);
3529                                continue;
3530                        }
3531
3532                        kfree(head->extent_op);
3533                        delayed_refs->num_heads--;
3534                        if (list_empty(&head->cluster))
3535                                delayed_refs->num_heads_ready--;
3536                        list_del_init(&head->cluster);
3537                }
3538                ref->in_tree = 0;
3539                rb_erase(&ref->rb_node, &delayed_refs->root);
3540                delayed_refs->num_entries--;
3541
3542                spin_unlock(&delayed_refs->lock);
3543                btrfs_put_delayed_ref(ref);
3544
3545                cond_resched();
3546                spin_lock(&delayed_refs->lock);
3547        }
3548
3549        spin_unlock(&delayed_refs->lock);
3550
3551        return ret;
3552}
3553
3554static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
3555{
3556        struct btrfs_pending_snapshot *snapshot;
3557        struct list_head splice;
3558
3559        INIT_LIST_HEAD(&splice);
3560
3561        list_splice_init(&t->pending_snapshots, &splice);
3562
3563        while (!list_empty(&splice)) {
3564                snapshot = list_entry(splice.next,
3565                                      struct btrfs_pending_snapshot,
3566                                      list);
3567
3568                list_del_init(&snapshot->list);
3569
3570                kfree(snapshot);
3571        }
3572}
3573
3574static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
3575{
3576        struct btrfs_inode *btrfs_inode;
3577        struct list_head splice;
3578
3579        INIT_LIST_HEAD(&splice);
3580
3581        spin_lock(&root->fs_info->delalloc_lock);
3582        list_splice_init(&root->fs_info->delalloc_inodes, &splice);
3583
3584        while (!list_empty(&splice)) {
3585                btrfs_inode = list_entry(splice.next, struct btrfs_inode,
3586                                    delalloc_inodes);
3587
3588                list_del_init(&btrfs_inode->delalloc_inodes);
3589
3590                btrfs_invalidate_inodes(btrfs_inode->root);
3591        }
3592
3593        spin_unlock(&root->fs_info->delalloc_lock);
3594}
3595
3596static int btrfs_destroy_marked_extents(struct btrfs_root *root,
3597                                        struct extent_io_tree *dirty_pages,
3598                                        int mark)
3599{
3600        int ret;
3601        struct page *page;
3602        struct inode *btree_inode = root->fs_info->btree_inode;
3603        struct extent_buffer *eb;
3604        u64 start = 0;
3605        u64 end;
3606        u64 offset;
3607        unsigned long index;
3608
3609        while (1) {
3610                ret = find_first_extent_bit(dirty_pages, start, &start, &end,
3611                                            mark);
3612                if (ret)
3613                        break;
3614
3615                clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
3616                while (start <= end) {
3617                        index = start >> PAGE_CACHE_SHIFT;
3618                        start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
3619                        page = find_get_page(btree_inode->i_mapping, index);
3620                        if (!page)
3621                                continue;
3622                        offset = page_offset(page);
3623
3624                        spin_lock(&dirty_pages->buffer_lock);
3625                        eb = radix_tree_lookup(
3626                             &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
3627                                               offset >> PAGE_CACHE_SHIFT);
3628                        spin_unlock(&dirty_pages->buffer_lock);
3629                        if (eb)
3630                                ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
3631                                                         &eb->bflags);
3632                        if (PageWriteback(page))
3633                                end_page_writeback(page);
3634
3635                        lock_page(page);
3636                        if (PageDirty(page)) {
3637                                clear_page_dirty_for_io(page);
3638                                spin_lock_irq(&page->mapping->tree_lock);
3639                                radix_tree_tag_clear(&page->mapping->page_tree,
3640                                                        page_index(page),
3641                                                        PAGECACHE_TAG_DIRTY);
3642                                spin_unlock_irq(&page->mapping->tree_lock);
3643                        }
3644
3645                        unlock_page(page);
3646                        page_cache_release(page);
3647                }
3648        }
3649
3650        return ret;
3651}
3652
3653static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
3654                                       struct extent_io_tree *pinned_extents)
3655{
3656        struct extent_io_tree *unpin;
3657        u64 start;
3658        u64 end;
3659        int ret;
3660        bool loop = true;
3661
3662        unpin = pinned_extents;
3663again:
3664        while (1) {
3665                ret = find_first_extent_bit(unpin, 0, &start, &end,
3666                                            EXTENT_DIRTY);
3667                if (ret)
3668                        break;
3669
3670                /* opt_discard */
3671                if (btrfs_test_opt(root, DISCARD))
3672                        ret = btrfs_error_discard_extent(root, start,
3673                                                         end + 1 - start,
3674                                                         NULL);
3675
3676                clear_extent_dirty(unpin, start, end, GFP_NOFS);
3677                btrfs_error_unpin_extent_range(root, start, end);
3678                cond_resched();
3679        }
3680
3681        if (loop) {
3682                if (unpin == &root->fs_info->freed_extents[0])
3683                        unpin = &root->fs_info->freed_extents[1];
3684                else
3685                        unpin = &root->fs_info->freed_extents[0];
3686                loop = false;
3687                goto again;
3688        }
3689
3690        return 0;
3691}
3692
3693void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
3694                                   struct btrfs_root *root)
3695{
3696        btrfs_destroy_delayed_refs(cur_trans, root);
3697        btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
3698                                cur_trans->dirty_pages.dirty_bytes);
3699
3700        /* FIXME: cleanup wait for commit */
3701        cur_trans->in_commit = 1;
3702        cur_trans->blocked = 1;
3703        wake_up(&root->fs_info->transaction_blocked_wait);
3704
3705        cur_trans->blocked = 0;
3706        wake_up(&root->fs_info->transaction_wait);
3707
3708        cur_trans->commit_done = 1;
3709        wake_up(&cur_trans->commit_wait);
3710
3711        btrfs_destroy_delayed_inodes(root);
3712        btrfs_assert_delayed_root_empty(root);
3713
3714        btrfs_destroy_pending_snapshots(cur_trans);
3715
3716        btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
3717                                     EXTENT_DIRTY);
3718        btrfs_destroy_pinned_extent(root,
3719                                    root->fs_info->pinned_extents);
3720
3721        /*
3722        memset(cur_trans, 0, sizeof(*cur_trans));
3723        kmem_cache_free(btrfs_transaction_cachep, cur_trans);
3724        */
3725}
3726
3727int btrfs_cleanup_transaction(struct btrfs_root *root)
3728{
3729        struct btrfs_transaction *t;
3730        LIST_HEAD(list);
3731
3732        mutex_lock(&root->fs_info->transaction_kthread_mutex);
3733
3734        spin_lock(&root->fs_info->trans_lock);
3735        list_splice_init(&root->fs_info->trans_list, &list);
3736        root->fs_info->trans_no_join = 1;
3737        spin_unlock(&root->fs_info->trans_lock);
3738
3739        while (!list_empty(&list)) {
3740                t = list_entry(list.next, struct btrfs_transaction, list);
3741                if (!t)
3742                        break;
3743
3744                btrfs_destroy_ordered_operations(root);
3745
3746                btrfs_destroy_ordered_extents(root);
3747
3748                btrfs_destroy_delayed_refs(t, root);
3749
3750                btrfs_block_rsv_release(root,
3751                                        &root->fs_info->trans_block_rsv,
3752                                        t->dirty_pages.dirty_bytes);
3753
3754                /* FIXME: cleanup wait for commit */
3755                t->in_commit = 1;
3756                t->blocked = 1;
3757                smp_mb();
3758                if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
3759                        wake_up(&root->fs_info->transaction_blocked_wait);
3760
3761                t->blocked = 0;
3762                smp_mb();
3763                if (waitqueue_active(&root->fs_info->transaction_wait))
3764                        wake_up(&root->fs_info->transaction_wait);
3765
3766                t->commit_done = 1;
3767                smp_mb();
3768                if (waitqueue_active(&t->commit_wait))
3769                        wake_up(&t->commit_wait);
3770
3771                btrfs_destroy_delayed_inodes(root);
3772                btrfs_assert_delayed_root_empty(root);
3773
3774                btrfs_destroy_pending_snapshots(t);
3775
3776                btrfs_destroy_delalloc_inodes(root);
3777
3778                spin_lock(&root->fs_info->trans_lock);
3779                root->fs_info->running_transaction = NULL;
3780                spin_unlock(&root->fs_info->trans_lock);
3781
3782                btrfs_destroy_marked_extents(root, &t->dirty_pages,
3783                                             EXTENT_DIRTY);
3784
3785                btrfs_destroy_pinned_extent(root,
3786                                            root->fs_info->pinned_extents);
3787
3788                atomic_set(&t->use_count, 0);
3789                list_del_init(&t->list);
3790                memset(t, 0, sizeof(*t));
3791                kmem_cache_free(btrfs_transaction_cachep, t);
3792        }
3793
3794        spin_lock(&root->fs_info->trans_lock);
3795        root->fs_info->trans_no_join = 0;
3796        spin_unlock(&root->fs_info->trans_lock);
3797        mutex_unlock(&root->fs_info->transaction_kthread_mutex);
3798
3799        return 0;
3800}
3801
3802static struct extent_io_ops btree_extent_io_ops = {
3803        .write_cache_pages_lock_hook = btree_lock_page_hook,
3804        .readpage_end_io_hook = btree_readpage_end_io_hook,
3805        .readpage_io_failed_hook = btree_io_failed_hook,
3806        .submit_bio_hook = btree_submit_bio_hook,
3807        /* note we're sharing with inode.c for the merge bio hook */
3808        .merge_bio_hook = btrfs_merge_bio_hook,
3809};
3810
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.