Merge commit v3.13-rc1 into kbuild/misc

author: Michal Marek <mmarek@suse.cz> 2014-01-02 08:02:06 -0500
committer: Michal Marek <mmarek@suse.cz> 2014-01-02 08:02:06 -0500
commit: 37e2c2a775fc887acd1432908478dfd532f7f00f (patch)
tree: e51ebc699d8e262fd47e0913be6a711cb1a7b565 /fs/btrfs
parent: 1c8ddae09f4c102b97c9086cc70347e89468a547 (diff)
parent: 6ce4eac1f600b34f2f7f58f9cd8f0503d79e42ae (diff)
51 files changed, 3065 insertions, 1223 deletions
diff --git a/fs/btrfs/Kconfig b/fs/btrfs/Kconfig
index 398cbd517be2..aa976eced2d2 100644
--- a/fs/btrfs/Kconfig
+++ b/fs/btrfs/Kconfig
@@ -9,12 +9,17 @@ config BTRFS_FS
        select XOR_BLOCKS
        help
-          Btrfs is a new filesystem with extents, writable snapshotting,
+          Btrfs is a general purpose copy-on-write filesystem with extents,
-          support for multiple devices and many more features.
+          writable snapshotting, support for multiple devices and many more
+          features focused on fault tolerance, repair and easy administration.
-          Btrfs is highly experimental, and THE DISK FORMAT IS NOT YET
+          The filesystem disk format is no longer unstable, and it's not
-          FINALIZED.  You should say N here unless you are interested in
+          expected to change unless there are strong reasons to do so. If there
-          testing Btrfs with non-critical data.
+          is a format change, file systems with a unchanged format will
+          continue to be mountable and usable by newer kernels.
+          For more information, please see the web pages at
+          http://btrfs.wiki.kernel.org.
          To compile this file system support as a module, choose M here. The
          module will be called btrfs.
@@ -59,7 +64,8 @@ config BTRFS_FS_RUN_SANITY_TESTS
        help
          This will run some basic sanity tests on the free space cache
          code to make sure it is acting as it should.  These are mostly
-          regression tests and are only really interesting to btrfs devlopers.
+          regression tests and are only really interesting to btrfs
+          developers.
          If unsure, say N.
diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index a91a6a355cc5..1a44e42d602a 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -14,4 +14,6 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
 btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
 btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
-btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o
+btrfs-$(CONFIG_BTRFS_FS_RUN_SANITY_TESTS) += tests/free-space-tests.o \
+        tests/extent-buffer-tests.o tests/btrfs-tests.o \
+        tests/extent-io-tests.o tests/inode-tests.o
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c
index e15d2b0d8d3b..0890c83643e9 100644
--- a/fs/btrfs/acl.c
+++ b/fs/btrfs/acl.c
@@ -229,7 +229,7 @@ int btrfs_init_acl(struct btrfs_trans_handle *trans,
                if (ret > 0) {
                        /* we need an acl */
                        ret = btrfs_set_acl(trans, inode, acl, ACL_TYPE_ACCESS);
-                } else {
+                } else if (ret < 0) {
                        cache_no_acl(inode);
                }
        } else {
diff --git a/fs/btrfs/async-thread.c b/fs/btrfs/async-thread.c
index 58b7d14b08ee..c1e0b0caf9cc 100644
--- a/fs/btrfs/async-thread.c
+++ b/fs/btrfs/async-thread.c
@@ -107,7 +107,8 @@ static void check_idle_worker(struct btrfs_worker_thread *worker)
                worker->idle = 1;
                /* the list may be empty if the worker is just starting */
-                if (!list_empty(&worker->worker_list)) {
+                if (!list_empty(&worker->worker_list) &&
+                    !worker->workers->stopping) {
                        list_move(&worker->worker_list,
                                 &worker->workers->idle_list);
                }
@@ -127,7 +128,8 @@ static void check_busy_worker(struct btrfs_worker_thread *worker)
                spin_lock_irqsave(&worker->workers->lock, flags);
                worker->idle = 0;
-                if (!list_empty(&worker->worker_list)) {
+                if (!list_empty(&worker->worker_list) &&
+                    !worker->workers->stopping) {
                        list_move_tail(&worker->worker_list,
                                      &worker->workers->worker_list);
                }
@@ -260,7 +262,7 @@ static struct btrfs_work *get_next_work(struct btrfs_worker_thread *worker,
        struct btrfs_work *work = NULL;
        struct list_head *cur = NULL;
-        if(!list_empty(prio_head))
+        if (!list_empty(prio_head))
                cur = prio_head->next;
        smp_mb();
@@ -412,6 +414,7 @@ void btrfs_stop_workers(struct btrfs_workers *workers)
        int can_stop;
        spin_lock_irq(&workers->lock);
+        workers->stopping = 1;
        list_splice_init(&workers->idle_list, &workers->worker_list);
        while (!list_empty(&workers->worker_list)) {
                cur = workers->worker_list.next;
@@ -455,6 +458,7 @@ void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,
        workers->ordered = 0;
        workers->atomic_start_pending = 0;
        workers->atomic_worker_start = async_helper;
+        workers->stopping = 0;
 }
 /*
@@ -480,15 +484,20 @@ static int __btrfs_start_workers(struct btrfs_workers *workers)
        atomic_set(&worker->num_pending, 0);
        atomic_set(&worker->refs, 1);
        worker->workers = workers;
-        worker->task = kthread_run(worker_loop, worker,
+        worker->task = kthread_create(worker_loop, worker,
-                                   "btrfs-%s-%d", workers->name,
+                                      "btrfs-%s-%d", workers->name,
-                                   workers->num_workers + 1);
+                                      workers->num_workers + 1);
        if (IS_ERR(worker->task)) {
                ret = PTR_ERR(worker->task);
-                kfree(worker);
                goto fail;
        }
        spin_lock_irq(&workers->lock);
+        if (workers->stopping) {
+                spin_unlock_irq(&workers->lock);
+                ret = -EINVAL;
+                goto fail_kthread;
+        }
        list_add_tail(&worker->worker_list, &workers->idle_list);
        worker->idle = 1;
        workers->num_workers++;
@@ -496,8 +505,13 @@ static int __btrfs_start_workers(struct btrfs_workers *workers)
        WARN_ON(workers->num_workers_starting < 0);
        spin_unlock_irq(&workers->lock);
+        wake_up_process(worker->task);
        return 0;
+fail_kthread:
+        kthread_stop(worker->task);
 fail:
+        kfree(worker);
        spin_lock_irq(&workers->lock);
        workers->num_workers_starting--;
        spin_unlock_irq(&workers->lock);
diff --git a/fs/btrfs/async-thread.h b/fs/btrfs/async-thread.h
index 063698b90ce2..1f26792683ed 100644
--- a/fs/btrfs/async-thread.h
+++ b/fs/btrfs/async-thread.h
@@ -107,6 +107,8 @@ struct btrfs_workers {
        /* extra name for this worker, used for current->name */
        char *name;
+        int stopping;
 };
 void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work);
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 0552a599b28f..3775947429b2 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -185,6 +185,9 @@ static int __add_prelim_ref(struct list_head *head, u64 root_id,
 {
        struct __prelim_ref *ref;
+        if (root_id == BTRFS_DATA_RELOC_TREE_OBJECTID)
+                return 0;
        ref = kmem_cache_alloc(btrfs_prelim_ref_cache, gfp_mask);
        if (!ref)
                return -ENOMEM;
@@ -323,8 +326,7 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
        eb = path->nodes[level];
        while (!eb) {
-                if (!level) {
+                if (WARN_ON(!level)) {
-                        WARN_ON(1);
                        ret = 1;
                        goto out;
                }
@@ -1619,7 +1621,7 @@ static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
                btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
                btrfs_release_path(path);
-                item = btrfs_item_nr(eb, slot);
+                item = btrfs_item_nr(slot);
                iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
                for (cur = 0; cur < btrfs_item_size(eb, item); cur += len) {
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index d0ae226926ee..ac0b39db27d1 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -19,6 +19,7 @@
 #ifndef __BTRFS_I__
 #define __BTRFS_I__
+#include <linux/hash.h>
 #include "extent_map.h"
 #include "extent_io.h"
 #include "ordered-data.h"
@@ -179,6 +180,25 @@ static inline struct btrfs_inode *BTRFS_I(struct inode *inode)
        return container_of(inode, struct btrfs_inode, vfs_inode);
 }
+static inline unsigned long btrfs_inode_hash(u64 objectid,
+                                             const struct btrfs_root *root)
+{
+        u64 h = objectid ^ (root->objectid * GOLDEN_RATIO_PRIME);
+#if BITS_PER_LONG == 32
+        h = (h >> 32) ^ (h & 0xffffffff);
+#endif
+        return (unsigned long)h;
+}
+static inline void btrfs_insert_inode_hash(struct inode *inode)
+{
+        unsigned long h = btrfs_inode_hash(inode->i_ino, BTRFS_I(inode)->root);
+        __insert_inode_hash(inode, h);
+}
 static inline u64 btrfs_ino(struct inode *inode)
 {
        u64 ino = BTRFS_I(inode)->location.objectid;
@@ -213,7 +233,10 @@ static inline bool btrfs_is_free_space_inode(struct inode *inode)
 static inline int btrfs_inode_in_log(struct inode *inode, u64 generation)
 {
        if (BTRFS_I(inode)->logged_trans == generation &&
-            BTRFS_I(inode)->last_sub_trans <= BTRFS_I(inode)->last_log_commit)
+            BTRFS_I(inode)->last_sub_trans <=
+            BTRFS_I(inode)->last_log_commit &&
+            BTRFS_I(inode)->last_sub_trans <=
+            BTRFS_I(inode)->root->last_log_commit)
                return 1;
        return 0;
 }
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 1c47be187240..b50764bef141 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -77,6 +77,15 @@
 * the integrity of (super)-block write requests, do not
 * enable the config option BTRFS_FS_CHECK_INTEGRITY to
 * include and compile the integrity check tool.
+ *
+ * Expect millions of lines of information in the kernel log with an
+ * enabled check_int_print_mask. Therefore set LOG_BUF_SHIFT in the
+ * kernel config to at least 26 (which is 64MB). Usually the value is
+ * limited to 21 (which is 2MB) in init/Kconfig. The file needs to be
+ * changed like this before LOG_BUF_SHIFT can be set to a high value:
+ * config LOG_BUF_SHIFT
+ *       int "Kernel log buffer size (16 => 64KB, 17 => 128KB)"
+ *       range 12 30
 */
 #include <linux/sched.h>
@@ -124,6 +133,7 @@
 #define BTRFSIC_PRINT_MASK_INITIAL_DATABASE                     0x00000400
 #define BTRFSIC_PRINT_MASK_NUM_COPIES                           0x00000800
 #define BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS                0x00001000
+#define BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE                0x00002000
 struct btrfsic_dev_state;
 struct btrfsic_state;
@@ -1038,7 +1048,7 @@ leaf_item_out_of_bounce_error:
                                                     disk_item_offset,
                                                     sizeof(struct btrfs_item));
                        item_offset = btrfs_stack_item_offset(&disk_item);
-                        item_size = btrfs_stack_item_offset(&disk_item);
+                        item_size = btrfs_stack_item_size(&disk_item);
                        disk_key = &disk_item.key;
                        type = btrfs_disk_key_type(disk_key);
@@ -1900,7 +1910,9 @@ again:
                                                               dev_state,
                                                               dev_bytenr);
                        }
-                        if (block->logical_bytenr != bytenr) {
+                        if (block->logical_bytenr != bytenr &&
+                            !(!block->is_metadata &&
+                              block->logical_bytenr == 0))
                                printk(KERN_INFO
                                       "Written block @%llu (%s/%llu/%d)"
                                       " found in hash table, %c,"
@@ -1910,15 +1922,14 @@ again:
                                       block->mirror_num,
                                       btrfsic_get_block_type(state, block),
                                       block->logical_bytenr);
-                                block->logical_bytenr = bytenr;
+                        else if (state->print_mask & BTRFSIC_PRINT_MASK_VERBOSE)
-                        } else if (state->print_mask &
-                                   BTRFSIC_PRINT_MASK_VERBOSE)
                                printk(KERN_INFO
                                       "Written block @%llu (%s/%llu/%d)"
                                       " found in hash table, %c.\n",
                                       bytenr, dev_state->name, dev_bytenr,
                                       block->mirror_num,
                                       btrfsic_get_block_type(state, block));
+                        block->logical_bytenr = bytenr;
                } else {
                        if (num_pages * PAGE_CACHE_SIZE <
                            state->datablock_size) {
@@ -2463,10 +2474,8 @@ static int btrfsic_process_written_superblock(
                }
        }
-        if (-1 == btrfsic_check_all_ref_blocks(state, superblock, 0)) {
+        if (WARN_ON(-1 == btrfsic_check_all_ref_blocks(state, superblock, 0)))
-                WARN_ON(1);
                btrfsic_dump_tree(state);
-        }
        return 0;
 }
@@ -2906,7 +2915,7 @@ static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state,
                btrfsic_release_block_ctx(&block_ctx);
        }
-        if (!match) {
+        if (WARN_ON(!match)) {
                printk(KERN_INFO "btrfs: attempt to write M-block which contains logical bytenr that doesn't map to dev+physical bytenr of submit_bio,"
                       " buffer->log_bytenr=%llu, submit_bio(bdev=%s,"
                       " phys_bytenr=%llu)!\n",
@@ -2923,7 +2932,6 @@ static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state,
                               bytenr, block_ctx.dev->name,
                               block_ctx.dev_bytenr, mirror_num);
                }
-                WARN_ON(1);
        }
 }
@@ -3017,6 +3025,7 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
            (rw & WRITE) && NULL != bio->bi_io_vec) {
                unsigned int i;
                u64 dev_bytenr;
+                u64 cur_bytenr;
                int bio_is_patched;
                char **mapped_datav;
@@ -3035,6 +3044,7 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
                                       GFP_NOFS);
                if (!mapped_datav)
                        goto leave;
+                cur_bytenr = dev_bytenr;
                for (i = 0; i < bio->bi_vcnt; i++) {
                        BUG_ON(bio->bi_io_vec[i].bv_len != PAGE_CACHE_SIZE);
                        mapped_datav[i] = kmap(bio->bi_io_vec[i].bv_page);
@@ -3046,16 +3056,13 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
                                kfree(mapped_datav);
                                goto leave;
                        }
-                        if ((BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
+                        if (dev_state->state->print_mask &
-                             BTRFSIC_PRINT_MASK_VERBOSE) ==
+                            BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE)
-                            (dev_state->state->print_mask &
-                             (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
-                              BTRFSIC_PRINT_MASK_VERBOSE)))
                                printk(KERN_INFO
-                                       "#%u: page=%p, len=%u, offset=%u\n",
+                                       "#%u: bytenr=%llu, len=%u, offset=%u\n",
-                                       i, bio->bi_io_vec[i].bv_page,
+                                       i, cur_bytenr, bio->bi_io_vec[i].bv_len,
-                                       bio->bi_io_vec[i].bv_len,
                                       bio->bi_io_vec[i].bv_offset);
+                        cur_bytenr += bio->bi_io_vec[i].bv_len;
                }
                btrfsic_process_written_block(dev_state, dev_bytenr,
                                              mapped_datav, bio->bi_vcnt,
diff --git a/fs/btrfs/compat.h b/fs/btrfs/compat.h
deleted file mode 100644
index 7c4503ef6efd..000000000000
--- a/fs/btrfs/compat.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#ifndef _COMPAT_H_
-#define _COMPAT_H_
-#define btrfs_drop_nlink(inode) drop_nlink(inode)
-#define btrfs_inc_nlink(inode)  inc_nlink(inode)
-#endif /* _COMPAT_H_ */
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 6aad98cb343f..1499b27b4186 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -32,7 +32,6 @@
 #include <linux/writeback.h>
 #include <linux/bit_spinlock.h>
 #include <linux/slab.h>
-#include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -360,7 +359,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
        bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
        bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
-        if(!bio) {
+        if (!bio) {
                kfree(cb);
                return -ENOMEM;
        }
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 64346721173f..316136bd6dd7 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -274,7 +274,7 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans,
        else
                btrfs_set_header_owner(cow, new_root_objectid);
-        write_extent_buffer(cow, root->fs_info->fsid, btrfs_header_fsid(cow),
+        write_extent_buffer(cow, root->fs_info->fsid, btrfs_header_fsid(),
                            BTRFS_FSID_SIZE);
        WARN_ON(btrfs_header_generation(buf) > trans->transid);
@@ -996,7 +996,7 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
        else
                btrfs_set_header_owner(cow, root->root_key.objectid);
-        write_extent_buffer(cow, root->fs_info->fsid, btrfs_header_fsid(cow),
+        write_extent_buffer(cow, root->fs_info->fsid, btrfs_header_fsid(),
                            BTRFS_FSID_SIZE);
        ret = update_ref_for_cow(trans, root, buf, cow, &last_ref);
@@ -1005,8 +1005,11 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans,
                return ret;
        }
-        if (root->ref_cows)
+        if (root->ref_cows) {
-                btrfs_reloc_cow_block(trans, root, buf, cow);
+                ret = btrfs_reloc_cow_block(trans, root, buf, cow);
+                if (ret)
+                        return ret;
+        }
        if (buf == root->node) {
                WARN_ON(parent && parent != buf);
@@ -1282,11 +1285,10 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
                free_extent_buffer(eb_root);
                blocksize = btrfs_level_size(root, old_root->level);
                old = read_tree_block(root, logical, blocksize, 0);
-                if (!old || !extent_buffer_uptodate(old)) {
+                if (WARN_ON(!old || !extent_buffer_uptodate(old))) {
                        free_extent_buffer(old);
                        pr_warn("btrfs: failed to read tree block %llu from get_old_root\n",
                                logical);
-                        WARN_ON(1);
                } else {
                        eb = btrfs_clone_extent_buffer(old);
                        free_extent_buffer(old);
@@ -2755,7 +2757,7 @@ int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
        int level;
        int lowest_unlock = 1;
        u8 lowest_level = 0;
-        int prev_cmp;
+        int prev_cmp = -1;
        lowest_level = p->lowest_level;
        WARN_ON(p->nodes[0] != NULL);
@@ -2766,7 +2768,6 @@ int btrfs_search_old_slot(struct btrfs_root *root, struct btrfs_key *key,
        }
 again:
-        prev_cmp = -1;
        b = get_old_root(root, time_seq);
        level = btrfs_header_level(b);
        p->locks[level] = BTRFS_READ_LOCK;
@@ -2784,6 +2785,11 @@ again:
                 */
                btrfs_unlock_up_safe(p, level + 1);
+                /*
+                 * Since we can unwind eb's we want to do a real search every
+                 * time.
+                 */
+                prev_cmp = -1;
                ret = key_search(b, key, level, &prev_cmp, &slot);
                if (level != 0) {
@@ -3145,7 +3151,7 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
        btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
        btrfs_set_header_owner(c, root->root_key.objectid);
-        write_extent_buffer(c, root->fs_info->fsid, btrfs_header_fsid(c),
+        write_extent_buffer(c, root->fs_info->fsid, btrfs_header_fsid(),
                            BTRFS_FSID_SIZE);
        write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
@@ -3284,7 +3290,7 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
        btrfs_set_header_backref_rev(split, BTRFS_MIXED_BACKREF_REV);
        btrfs_set_header_owner(split, root->root_key.objectid);
        write_extent_buffer(split, root->fs_info->fsid,
-                            btrfs_header_fsid(split), BTRFS_FSID_SIZE);
+                            btrfs_header_fsid(), BTRFS_FSID_SIZE);
        write_extent_buffer(split, root->fs_info->chunk_tree_uuid,
                            btrfs_header_chunk_tree_uuid(split),
                            BTRFS_UUID_SIZE);
@@ -3334,8 +3340,8 @@ static int leaf_space_used(struct extent_buffer *l, int start, int nr)
        if (!nr)
                return 0;
        btrfs_init_map_token(&token);
-        start_item = btrfs_item_nr(l, start);
+        start_item = btrfs_item_nr(start);
-        end_item = btrfs_item_nr(l, end);
+        end_item = btrfs_item_nr(end);
        data_len = btrfs_token_item_offset(l, start_item, &token) +
                btrfs_token_item_size(l, start_item, &token);
        data_len = data_len - btrfs_token_item_offset(l, end_item, &token);
@@ -3403,7 +3409,7 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
        slot = path->slots[1];
        i = left_nritems - 1;
        while (i >= nr) {
-                item = btrfs_item_nr(left, i);
+                item = btrfs_item_nr(i);
                if (!empty && push_items > 0) {
                        if (path->slots[0] > i)
@@ -3467,7 +3473,7 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
        btrfs_set_header_nritems(right, right_nritems);
        push_space = BTRFS_LEAF_DATA_SIZE(root);
        for (i = 0; i < right_nritems; i++) {
-                item = btrfs_item_nr(right, i);
+                item = btrfs_item_nr(i);
                push_space -= btrfs_token_item_size(right, item, &token);
                btrfs_set_token_item_offset(right, item, push_space, &token);
        }
@@ -3609,7 +3615,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
                nr = min(right_nritems - 1, max_slot);
        for (i = 0; i < nr; i++) {
-                item = btrfs_item_nr(right, i);
+                item = btrfs_item_nr(i);
                if (!empty && push_items > 0) {
                        if (path->slots[0] < i)
@@ -3636,8 +3642,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
                ret = 1;
                goto out;
        }
-        if (!empty && push_items == btrfs_header_nritems(right))
+        WARN_ON(!empty && push_items == btrfs_header_nritems(right));
-                WARN_ON(1);
        /* push data from right to left */
        copy_extent_buffer(left, right,
@@ -3660,7 +3665,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
        for (i = old_left_nritems; i < old_left_nritems + push_items; i++) {
                u32 ioff;
-                item = btrfs_item_nr(left, i);
+                item = btrfs_item_nr(i);
                ioff = btrfs_token_item_offset(left, item, &token);
                btrfs_set_token_item_offset(left, item,
@@ -3691,7 +3696,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
        btrfs_set_header_nritems(right, right_nritems);
        push_space = BTRFS_LEAF_DATA_SIZE(root);
        for (i = 0; i < right_nritems; i++) {
-                item = btrfs_item_nr(right, i);
+                item = btrfs_item_nr(i);
                push_space = push_space - btrfs_token_item_size(right,
                                                                item, &token);
@@ -3832,7 +3837,7 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans,
                      btrfs_item_end_nr(l, mid);
        for (i = 0; i < nritems; i++) {
-                struct btrfs_item *item = btrfs_item_nr(right, i);
+                struct btrfs_item *item = btrfs_item_nr(i);
                u32 ioff;
                ioff = btrfs_token_item_offset(right, item, &token);
@@ -4013,7 +4018,7 @@ again:
                                    data_size > BTRFS_LEAF_DATA_SIZE(root)) {
                                        if (data_size && !tried_avoid_double)
                                                goto push_for_double;
-                                        split = 2 ;
+                                        split = 2;
                                }
                        }
                }
@@ -4039,7 +4044,7 @@ again:
        btrfs_set_header_owner(right, root->root_key.objectid);
        btrfs_set_header_level(right, 0);
        write_extent_buffer(right, root->fs_info->fsid,
-                            btrfs_header_fsid(right), BTRFS_FSID_SIZE);
+                            btrfs_header_fsid(), BTRFS_FSID_SIZE);
        write_extent_buffer(right, root->fs_info->chunk_tree_uuid,
                            btrfs_header_chunk_tree_uuid(right),
@@ -4174,7 +4179,7 @@ static noinline int split_item(struct btrfs_trans_handle *trans,
        btrfs_set_path_blocking(path);
-        item = btrfs_item_nr(leaf, path->slots[0]);
+        item = btrfs_item_nr(path->slots[0]);
        orig_offset = btrfs_item_offset(leaf, item);
        item_size = btrfs_item_size(leaf, item);
@@ -4197,7 +4202,7 @@ static noinline int split_item(struct btrfs_trans_handle *trans,
        btrfs_cpu_key_to_disk(&disk_key, new_key);
        btrfs_set_item_key(leaf, &disk_key, slot);
-        new_item = btrfs_item_nr(leaf, slot);
+        new_item = btrfs_item_nr(slot);
        btrfs_set_item_offset(leaf, new_item, orig_offset);
        btrfs_set_item_size(leaf, new_item, item_size - split_offset);
@@ -4336,7 +4341,7 @@ void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
        /* first correct the data pointers */
        for (i = slot; i < nritems; i++) {
                u32 ioff;
-                item = btrfs_item_nr(leaf, i);
+                item = btrfs_item_nr(i);
                ioff = btrfs_token_item_offset(leaf, item, &token);
                btrfs_set_token_item_offset(leaf, item,
@@ -4384,7 +4389,7 @@ void btrfs_truncate_item(struct btrfs_root *root, struct btrfs_path *path,
                        fixup_low_keys(root, path, &disk_key, 1);
        }
-        item = btrfs_item_nr(leaf, slot);
+        item = btrfs_item_nr(slot);
        btrfs_set_item_size(leaf, item, new_size);
        btrfs_mark_buffer_dirty(leaf);
@@ -4438,7 +4443,7 @@ void btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
        /* first correct the data pointers */
        for (i = slot; i < nritems; i++) {
                u32 ioff;
-                item = btrfs_item_nr(leaf, i);
+                item = btrfs_item_nr(i);
                ioff = btrfs_token_item_offset(leaf, item, &token);
                btrfs_set_token_item_offset(leaf, item,
@@ -4452,7 +4457,7 @@ void btrfs_extend_item(struct btrfs_root *root, struct btrfs_path *path,
        data_end = old_data;
        old_size = btrfs_item_size_nr(leaf, slot);
-        item = btrfs_item_nr(leaf, slot);
+        item = btrfs_item_nr(slot);
        btrfs_set_item_size(leaf, item, old_size + data_size);
        btrfs_mark_buffer_dirty(leaf);
@@ -4511,7 +4516,7 @@ void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
                for (i = slot; i < nritems; i++) {
                        u32 ioff;
-                        item = btrfs_item_nr(leaf, i);
+                        item = btrfs_item_nr( i);
                        ioff = btrfs_token_item_offset(leaf, item, &token);
                        btrfs_set_token_item_offset(leaf, item,
                                                    ioff - total_data, &token);
@@ -4532,7 +4537,7 @@ void setup_items_for_insert(struct btrfs_root *root, struct btrfs_path *path,
        for (i = 0; i < nr; i++) {
                btrfs_cpu_key_to_disk(&disk_key, cpu_key + i);
                btrfs_set_item_key(leaf, &disk_key, slot + i);
-                item = btrfs_item_nr(leaf, slot + i);
+                item = btrfs_item_nr(slot + i);
                btrfs_set_token_item_offset(leaf, item,
                                            data_end - data_size[i], &token);
                data_end -= data_size[i];
@@ -4727,7 +4732,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                for (i = slot + nr; i < nritems; i++) {
                        u32 ioff;
-                        item = btrfs_item_nr(leaf, i);
+                        item = btrfs_item_nr(i);
                        ioff = btrfs_token_item_offset(leaf, item, &token);
                        btrfs_set_token_item_offset(leaf, item,
                                                    ioff + dsize, &token);
@@ -4820,14 +4825,18 @@ static int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
        btrfs_item_key_to_cpu(path->nodes[0], &key, 0);
-        if (key.offset > 0)
+        if (key.offset > 0) {
                key.offset--;
-        else if (key.type > 0)
+        } else if (key.type > 0) {
                key.type--;
-        else if (key.objectid > 0)
+                key.offset = (u64)-1;
+        } else if (key.objectid > 0) {
                key.objectid--;
-        else
+                key.type = (u8)-1;
+                key.offset = (u64)-1;
+        } else {
                return 1;
+        }
        btrfs_release_path(path);
        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
@@ -4863,7 +4872,6 @@ static int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path)
 * was nothing in the tree that matched the search criteria.
 */
 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
-                         struct btrfs_key *max_key,
                         struct btrfs_path *path,
                         u64 min_trans)
 {
@@ -4908,10 +4916,8 @@ again:
                 * If it is too old, old, skip to the next one.
                 */
                while (slot < nritems) {
-                        u64 blockptr;
                        u64 gen;
-                        blockptr = btrfs_node_blockptr(cur, slot);
                        gen = btrfs_node_ptr_generation(cur, slot);
                        if (gen < min_trans) {
                                slot++;
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 3c1da6f98a4d..54ab86127f7a 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -47,6 +47,12 @@ extern struct kmem_cache *btrfs_path_cachep;
 extern struct kmem_cache *btrfs_free_space_cachep;
 struct btrfs_ordered_sum;
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+#define STATIC noinline
+#else
+#define STATIC static noinline
+#endif
 #define BTRFS_MAGIC 0x4D5F53665248425FULL /* ascii _BHRfS_M, no null */
 #define BTRFS_MAX_MIRRORS 3
@@ -1118,15 +1124,6 @@ struct btrfs_space_info {
         */
        struct percpu_counter total_bytes_pinned;
-        /*
-         * we bump reservation progress every time we decrement
-         * bytes_reserved.  This way people waiting for reservations
-         * know something good has happened and they can check
-         * for progress.  The number here isn't to be trusted, it
-         * just shows reclaim activity
-         */
-        unsigned long reservation_progress;
        unsigned int full:1;    /* indicates that we cannot allocate any more
                                   chunks for this space */
        unsigned int chunk_alloc:1;     /* set if we are allocating a chunk */
@@ -1589,7 +1586,6 @@ struct btrfs_fs_info {
        atomic_t scrubs_paused;
        atomic_t scrub_cancel_req;
        wait_queue_head_t scrub_pause_wait;
-        struct rw_semaphore scrub_super_lock;
        int scrub_workers_refcnt;
        struct btrfs_workers scrub_workers;
        struct btrfs_workers scrub_wr_completion_workers;
@@ -1733,7 +1729,9 @@ struct btrfs_root {
        int ref_cows;
        int track_dirty;
        int in_radix;
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+        int dummy_root;
+#endif
        u64 defrag_trans_start;
        struct btrfs_key defrag_progress;
        struct btrfs_key defrag_max;
@@ -2470,8 +2468,7 @@ static inline unsigned long btrfs_item_nr_offset(int nr)
                sizeof(struct btrfs_item) * nr;
 }
-static inline struct btrfs_item *btrfs_item_nr(struct extent_buffer *eb,
+static inline struct btrfs_item *btrfs_item_nr(int nr)
-                                               int nr)
 {
        return (struct btrfs_item *)btrfs_item_nr_offset(nr);
 }
@@ -2484,30 +2481,30 @@ static inline u32 btrfs_item_end(struct extent_buffer *eb,
 static inline u32 btrfs_item_end_nr(struct extent_buffer *eb, int nr)
 {
-        return btrfs_item_end(eb, btrfs_item_nr(eb, nr));
+        return btrfs_item_end(eb, btrfs_item_nr(nr));
 }
 static inline u32 btrfs_item_offset_nr(struct extent_buffer *eb, int nr)
 {
-        return btrfs_item_offset(eb, btrfs_item_nr(eb, nr));
+        return btrfs_item_offset(eb, btrfs_item_nr(nr));
 }
 static inline u32 btrfs_item_size_nr(struct extent_buffer *eb, int nr)
 {
-        return btrfs_item_size(eb, btrfs_item_nr(eb, nr));
+        return btrfs_item_size(eb, btrfs_item_nr(nr));
 }
 static inline void btrfs_item_key(struct extent_buffer *eb,
                           struct btrfs_disk_key *disk_key, int nr)
 {
-        struct btrfs_item *item = btrfs_item_nr(eb, nr);
+        struct btrfs_item *item = btrfs_item_nr(nr);
        read_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
 static inline void btrfs_set_item_key(struct extent_buffer *eb,
                               struct btrfs_disk_key *disk_key, int nr)
 {
-        struct btrfs_item *item = btrfs_item_nr(eb, nr);
+        struct btrfs_item *item = btrfs_item_nr(nr);
        write_eb_member(eb, item, struct btrfs_item, key, disk_key);
 }
@@ -2675,7 +2672,7 @@ static inline void btrfs_set_header_backref_rev(struct extent_buffer *eb,
        btrfs_set_header_flags(eb, flags);
 }
-static inline unsigned long btrfs_header_fsid(struct extent_buffer *eb)
+static inline unsigned long btrfs_header_fsid(void)
 {
        return offsetof(struct btrfs_header, fsid);
 }
@@ -3114,11 +3111,6 @@ static inline u32 btrfs_level_size(struct btrfs_root *root, int level)
        ((unsigned long)(btrfs_leaf_data(leaf) + \
        btrfs_item_offset_nr(leaf, slot)))
-static inline struct dentry *fdentry(struct file *file)
-{
-        return file->f_path.dentry;
-}
 static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)
 {
        return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
@@ -3135,7 +3127,7 @@ static inline u64 btrfs_calc_trans_metadata_size(struct btrfs_root *root,
                                                 unsigned num_items)
 {
        return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
-                3 * num_items;
+                2 * num_items;
 }
 /*
@@ -3317,7 +3309,6 @@ int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path,
                        struct btrfs_key *key, int lowest_level,
                        u64 min_trans);
 int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key,
-                         struct btrfs_key *max_key,
                         struct btrfs_path *path,
                         u64 min_trans);
 enum btrfs_compare_tree_result {
@@ -3622,9 +3613,6 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                           struct btrfs_ordered_sum *sums);
 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
                       struct bio *bio, u64 file_start, int contig);
-int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root, struct btrfs_path *path,
-                        u64 isize);
 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
                             struct list_head *list, int search_commit);
 /* inode.c */
@@ -3684,8 +3672,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                               u32 min_type);
 int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput);
-int btrfs_start_all_delalloc_inodes(struct btrfs_fs_info *fs_info,
+int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput);
-                                    int delay_iput);
 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
                              struct extent_state **cached_state);
 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
@@ -3754,9 +3741,6 @@ void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
 void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                             int skip_pinned);
-int btrfs_replace_extent_cache(struct inode *inode, struct extent_map *replace,
-                               u64 start, u64 end, int skip_pinned,
-                               int modified);
 extern const struct file_operations btrfs_file_operations;
 int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root, struct inode *inode,
@@ -3939,9 +3923,9 @@ int btrfs_update_reloc_root(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root);
 int btrfs_recover_relocation(struct btrfs_root *root);
 int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len);
-void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
+int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
-                           struct btrfs_root *root, struct extent_buffer *buf,
+                          struct btrfs_root *root, struct extent_buffer *buf,
-                           struct extent_buffer *cow);
+                          struct extent_buffer *cow);
 void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans,
                              struct btrfs_pending_snapshot *pending,
                              u64 *bytes_to_reserve);
@@ -3953,9 +3937,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
                    u64 end, struct btrfs_scrub_progress *progress,
                    int readonly, int is_dev_replace);
 void btrfs_scrub_pause(struct btrfs_root *root);
-void btrfs_scrub_pause_super(struct btrfs_root *root);
 void btrfs_scrub_continue(struct btrfs_root *root);
-void btrfs_scrub_continue_super(struct btrfs_root *root);
 int btrfs_scrub_cancel(struct btrfs_fs_info *info);
 int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
                           struct btrfs_device *dev);
@@ -4037,5 +4019,9 @@ static inline int btrfs_defrag_cancelled(struct btrfs_fs_info *fs_info)
        return signal_pending(current);
 }
+/* Sanity test specific functions */
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+void btrfs_test_destroy_inode(struct inode *inode);
+#endif
 #endif
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index cbd9523ad09c..8d292fbae659 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -108,8 +108,8 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode)
                        return node;
                }
                btrfs_inode->delayed_node = node;
-                atomic_inc(&node->refs);        /* can be accessed */
+                /* can be accessed and cached in the inode */
-                atomic_inc(&node->refs);        /* cached in the inode */
+                atomic_add(2, &node->refs);
                spin_unlock(&root->inode_lock);
                return node;
        }
@@ -138,8 +138,8 @@ again:
                return ERR_PTR(-ENOMEM);
        btrfs_init_delayed_node(node, root, ino);
-        atomic_inc(&node->refs);        /* cached in the btrfs inode */
+        /* cached in the btrfs inode and can be accessed */
-        atomic_inc(&node->refs);        /* can be accessed */
+        atomic_add(2, &node->refs);
        ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
        if (ret) {
@@ -649,14 +649,13 @@ static int btrfs_delayed_inode_reserve_metadata(
                        goto out;
                ret = btrfs_block_rsv_migrate(src_rsv, dst_rsv, num_bytes);
-                if (!ret)
+                if (!WARN_ON(ret))
                        goto out;
                /*
                 * Ok this is a problem, let's just steal from the global rsv
                 * since this really shouldn't happen that often.
                 */
-                WARN_ON(1);
                ret = btrfs_block_rsv_migrate(&root->fs_info->global_block_rsv,
                                              dst_rsv, num_bytes);
                goto out;
@@ -771,13 +770,13 @@ static int btrfs_batch_insert_items(struct btrfs_root *root,
         */
        btrfs_set_path_blocking(path);
-        keys = kmalloc(sizeof(struct btrfs_key) * nitems, GFP_NOFS);
+        keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS);
        if (!keys) {
                ret = -ENOMEM;
                goto out;
        }
-        data_size = kmalloc(sizeof(u32) * nitems, GFP_NOFS);
+        data_size = kmalloc_array(nitems, sizeof(u32), GFP_NOFS);
        if (!data_size) {
                ret = -ENOMEM;
                goto error;
@@ -1174,8 +1173,10 @@ int btrfs_commit_inode_delayed_items(struct btrfs_trans_handle *trans,
        mutex_unlock(&delayed_node->mutex);
        path = btrfs_alloc_path();
-        if (!path)
+        if (!path) {
+                btrfs_release_delayed_node(delayed_node);
                return -ENOMEM;
+        }
        path->leave_spinning = 1;
        block_rsv = trans->block_rsv;
diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index a64435359385..2cfc3dfff64f 100644
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -26,7 +26,6 @@
 #include <linux/kthread.h>
 #include <linux/math64.h>
 #include <asm/div64.h>
-#include "compat.h"
 #include "ctree.h"
 #include "extent_map.h"
 #include "disk-io.h"
@@ -38,7 +37,6 @@
 #include "rcu-string.h"
 #include "dev-replace.h"
-static u64 btrfs_get_seconds_since_1970(void);
 static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
                                       int scrub_ret);
 static void btrfs_dev_replace_update_device_in_mapping_tree(
@@ -296,13 +294,6 @@ void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info)
                dev_replace->cursor_left_last_write_of_item;
 }
-static u64 btrfs_get_seconds_since_1970(void)
-{
-        struct timespec t = CURRENT_TIME_SEC;
-        return t.tv_sec;
-}
 int btrfs_dev_replace_start(struct btrfs_root *root,
                            struct btrfs_ioctl_dev_replace_args *args)
 {
@@ -375,7 +366,7 @@ int btrfs_dev_replace_start(struct btrfs_root *root,
        dev_replace->tgtdev = tgt_device;
        printk_in_rcu(KERN_INFO
-                      "btrfs: dev_replace from %s (devid %llu) to %s) started\n",
+                      "btrfs: dev_replace from %s (devid %llu) to %s started\n",
                      src_device->missing ? "<missing disk>" :
                        rcu_str_deref(src_device->name),
                      src_device->devid,
@@ -390,7 +381,7 @@ int btrfs_dev_replace_start(struct btrfs_root *root,
         * go to the tgtdev as well (refer to btrfs_map_block()).
         */
        dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
-        dev_replace->time_started = btrfs_get_seconds_since_1970();
+        dev_replace->time_started = get_seconds();
        dev_replace->cursor_left = 0;
        dev_replace->committed_cursor_left = 0;
        dev_replace->cursor_left_last_write_of_item = 0;
@@ -400,7 +391,7 @@ int btrfs_dev_replace_start(struct btrfs_root *root,
        args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
        btrfs_dev_replace_unlock(dev_replace);
-        btrfs_wait_all_ordered_extents(root->fs_info, 0);
+        btrfs_wait_ordered_roots(root->fs_info, -1);
        /* force writing the updated state information to disk */
        trans = btrfs_start_transaction(root, 0);
@@ -470,12 +461,12 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
         * flush all outstanding I/O and inode extent mappings before the
         * copy operation is declared as being finished
         */
-        ret = btrfs_start_all_delalloc_inodes(root->fs_info, 0);
+        ret = btrfs_start_delalloc_roots(root->fs_info, 0);
        if (ret) {
                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
                return ret;
        }
-        btrfs_wait_all_ordered_extents(root->fs_info, 0);
+        btrfs_wait_ordered_roots(root->fs_info, -1);
        trans = btrfs_start_transaction(root, 0);
        if (IS_ERR(trans)) {
@@ -493,7 +484,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
                          : BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED;
        dev_replace->tgtdev = NULL;
        dev_replace->srcdev = NULL;
-        dev_replace->time_stopped = btrfs_get_seconds_since_1970();
+        dev_replace->time_stopped = get_seconds();
        dev_replace->item_needs_writeback = 1;
        if (scrub_ret) {
@@ -535,10 +526,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
        list_add(&tgt_device->dev_alloc_list, &fs_info->fs_devices->alloc_list);
        btrfs_rm_dev_replace_srcdev(fs_info, src_device);
-        if (src_device->bdev) {
-                /* zero out the old super */
-                btrfs_scratch_superblock(src_device);
-        }
        /*
         * this is again a consistent state where no dev_replace procedure
         * is running, the target device is part of the filesystem, the
@@ -653,6 +641,9 @@ static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
        u64 result;
        int ret;
+        if (fs_info->sb->s_flags & MS_RDONLY)
+                return -EROFS;
        mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
        btrfs_dev_replace_lock(dev_replace);
        switch (dev_replace->replace_state) {
@@ -671,7 +662,7 @@ static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
                break;
        }
        dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED;
-        dev_replace->time_stopped = btrfs_get_seconds_since_1970();
+        dev_replace->time_stopped = get_seconds();
        dev_replace->item_needs_writeback = 1;
        btrfs_dev_replace_unlock(dev_replace);
        btrfs_scrub_cancel(fs_info);
@@ -706,7 +697,7 @@ void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)
        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
                dev_replace->replace_state =
                        BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED;
-                dev_replace->time_stopped = btrfs_get_seconds_since_1970();
+                dev_replace->time_stopped = get_seconds();
                dev_replace->item_needs_writeback = 1;
                pr_info("btrfs: suspending dev_replace for unmount\n");
                break;
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 79e594e341c7..c031ea3fd70f 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -58,7 +58,7 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle
                return ERR_PTR(ret);
        WARN_ON(ret > 0);
        leaf = path->nodes[0];
-        item = btrfs_item_nr(leaf, path->slots[0]);
+        item = btrfs_item_nr(path->slots[0]);
        ptr = btrfs_item_ptr(leaf, path->slots[0], char);
        BUG_ON(data_size > btrfs_item_size(leaf, item));
        ptr += btrfs_item_size(leaf, item) - data_size;
@@ -474,8 +474,10 @@ int verify_dir_item(struct btrfs_root *root,
        }
        /* BTRFS_MAX_XATTR_SIZE is the same for all dir items */
-        if (btrfs_dir_data_len(leaf, dir_item) > BTRFS_MAX_XATTR_SIZE(root)) {
+        if ((btrfs_dir_data_len(leaf, dir_item) +
-                printk(KERN_CRIT "btrfs: invalid dir item data len: %u\n",
+             btrfs_dir_name_len(leaf, dir_item)) > BTRFS_MAX_XATTR_SIZE(root)) {
+                printk(KERN_CRIT "btrfs: invalid dir item name + data len: %u + %u\n",
+                       (unsigned)btrfs_dir_name_len(leaf, dir_item),
                       (unsigned)btrfs_dir_data_len(leaf, dir_item));
                return 1;
        }
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 4cbb00af92ff..8072cfa8a3b1 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -33,7 +33,6 @@
 #include <linux/uuid.h>
 #include <linux/semaphore.h>
 #include <asm/unaligned.h>
-#include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -64,7 +63,6 @@ static void btrfs_destroy_ordered_operations(struct btrfs_transaction *t,
 static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
                                      struct btrfs_root *root);
-static void btrfs_evict_pending_snapshots(struct btrfs_transaction *t);
 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
                                        struct extent_io_tree *dirty_pages,
@@ -157,6 +155,7 @@ static struct btrfs_lockdep_keyset {
        { .id = BTRFS_TREE_LOG_OBJECTID,        .name_stem = "log"      },
        { .id = BTRFS_TREE_RELOC_OBJECTID,      .name_stem = "treloc"   },
        { .id = BTRFS_DATA_RELOC_TREE_OBJECTID, .name_stem = "dreloc"   },
+        { .id = BTRFS_UUID_TREE_OBJECTID,       .name_stem = "uuid"     },
        { .id = 0,                              .name_stem = "tree"     },
 };
@@ -476,14 +475,8 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
        if (page != eb->pages[0])
                return 0;
        found_start = btrfs_header_bytenr(eb);
-        if (found_start != start) {
+        if (WARN_ON(found_start != start || !PageUptodate(page)))
-                WARN_ON(1);
                return 0;
-        }
-        if (!PageUptodate(page)) {
-                WARN_ON(1);
-                return 0;
-        }
        csum_tree_block(root, eb, 0);
        return 0;
 }
@@ -495,7 +488,7 @@ static int check_tree_block_fsid(struct btrfs_root *root,
        u8 fsid[BTRFS_UUID_SIZE];
        int ret = 1;
-        read_extent_buffer(eb, fsid, btrfs_header_fsid(eb), BTRFS_FSID_SIZE);
+        read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
        while (fs_devices) {
                if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
                        ret = 0;
@@ -1104,8 +1097,7 @@ struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
 {
        struct inode *btree_inode = root->fs_info->btree_inode;
        struct extent_buffer *eb;
-        eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
+        eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree, bytenr);
-                                bytenr, blocksize);
        return eb;
 }
@@ -1228,14 +1220,18 @@ static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
        atomic_set(&root->refs, 1);
        root->log_transid = 0;
        root->last_log_commit = 0;
-        extent_io_tree_init(&root->dirty_log_pages,
+        if (fs_info)
-                             fs_info->btree_inode->i_mapping);
+                extent_io_tree_init(&root->dirty_log_pages,
+                                     fs_info->btree_inode->i_mapping);
        memset(&root->root_key, 0, sizeof(root->root_key));
        memset(&root->root_item, 0, sizeof(root->root_item));
        memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
        memset(&root->root_kobj, 0, sizeof(root->root_kobj));
-        root->defrag_trans_start = fs_info->generation;
+        if (fs_info)
+                root->defrag_trans_start = fs_info->generation;
+        else
+                root->defrag_trans_start = 0;
        init_completion(&root->kobj_unregister);
        root->defrag_running = 0;
        root->root_key.objectid = objectid;
@@ -1252,6 +1248,22 @@ static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
        return root;
 }
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+/* Should only be used by the testing infrastructure */
+struct btrfs_root *btrfs_alloc_dummy_root(void)
+{
+        struct btrfs_root *root;
+        root = btrfs_alloc_root(NULL);
+        if (!root)
+                return ERR_PTR(-ENOMEM);
+        __setup_root(4096, 4096, 4096, 4096, root, NULL, 1);
+        root->dummy_root = 1;
+        return root;
+}
+#endif
 struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
                                     struct btrfs_fs_info *fs_info,
                                     u64 objectid)
@@ -1291,7 +1303,7 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
        btrfs_set_header_owner(leaf, objectid);
        root->node = leaf;
-        write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(leaf),
+        write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(),
                            BTRFS_FSID_SIZE);
        write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
                            btrfs_header_chunk_tree_uuid(leaf),
@@ -1378,7 +1390,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
        root->node = leaf;
        write_extent_buffer(root->node, root->fs_info->fsid,
-                            btrfs_header_fsid(root->node), BTRFS_FSID_SIZE);
+                            btrfs_header_fsid(), BTRFS_FSID_SIZE);
        btrfs_mark_buffer_dirty(root->node);
        btrfs_tree_unlock(root->node);
        return root;
@@ -1560,8 +1572,9 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
        return ret;
 }
-struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
+struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
-                                              struct btrfs_key *location)
+                                     struct btrfs_key *location,
+                                     bool check_ref)
 {
        struct btrfs_root *root;
        int ret;
@@ -1585,7 +1598,7 @@ struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
 again:
        root = btrfs_lookup_fs_root(fs_info, location->objectid);
        if (root) {
-                if (btrfs_root_refs(&root->root_item) == 0)
+                if (check_ref && btrfs_root_refs(&root->root_item) == 0)
                        return ERR_PTR(-ENOENT);
                return root;
        }
@@ -1594,7 +1607,7 @@ again:
        if (IS_ERR(root))
                return root;
-        if (btrfs_root_refs(&root->root_item) == 0) {
+        if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
                ret = -ENOENT;
                goto fail;
        }
@@ -1778,6 +1791,9 @@ sleep:
                wake_up_process(root->fs_info->cleaner_kthread);
                mutex_unlock(&root->fs_info->transaction_kthread_mutex);
+                if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
+                                      &root->fs_info->fs_state)))
+                        btrfs_cleanup_transaction(root);
                if (!try_to_freeze()) {
                        set_current_state(TASK_INTERRUPTIBLE);
                        if (!kthread_should_stop() &&
@@ -2011,50 +2027,28 @@ static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
        btrfs_stop_workers(&fs_info->qgroup_rescan_workers);
 }
+static void free_root_extent_buffers(struct btrfs_root *root)
+{
+        if (root) {
+                free_extent_buffer(root->node);
+                free_extent_buffer(root->commit_root);
+                root->node = NULL;
+                root->commit_root = NULL;
+        }
+}
 /* helper to cleanup tree roots */
 static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
 {
-        free_extent_buffer(info->tree_root->node);
+        free_root_extent_buffers(info->tree_root);
-        free_extent_buffer(info->tree_root->commit_root);
-        info->tree_root->node = NULL;
+        free_root_extent_buffers(info->dev_root);
-        info->tree_root->commit_root = NULL;
+        free_root_extent_buffers(info->extent_root);
+        free_root_extent_buffers(info->csum_root);
-        if (info->dev_root) {
+        free_root_extent_buffers(info->quota_root);
-                free_extent_buffer(info->dev_root->node);
+        free_root_extent_buffers(info->uuid_root);
-                free_extent_buffer(info->dev_root->commit_root);
+        if (chunk_root)
-                info->dev_root->node = NULL;
+                free_root_extent_buffers(info->chunk_root);
-                info->dev_root->commit_root = NULL;
-        }
-        if (info->extent_root) {
-                free_extent_buffer(info->extent_root->node);
-                free_extent_buffer(info->extent_root->commit_root);
-                info->extent_root->node = NULL;
-                info->extent_root->commit_root = NULL;
-        }
-        if (info->csum_root) {
-                free_extent_buffer(info->csum_root->node);
-                free_extent_buffer(info->csum_root->commit_root);
-                info->csum_root->node = NULL;
-                info->csum_root->commit_root = NULL;
-        }
-        if (info->quota_root) {
-                free_extent_buffer(info->quota_root->node);
-                free_extent_buffer(info->quota_root->commit_root);
-                info->quota_root->node = NULL;
-                info->quota_root->commit_root = NULL;
-        }
-        if (info->uuid_root) {
-                free_extent_buffer(info->uuid_root->node);
-                free_extent_buffer(info->uuid_root->commit_root);
-                info->uuid_root->node = NULL;
-                info->uuid_root->commit_root = NULL;
-        }
-        if (chunk_root) {
-                free_extent_buffer(info->chunk_root->node);
-                free_extent_buffer(info->chunk_root->commit_root);
-                info->chunk_root->node = NULL;
-                info->chunk_root->commit_root = NULL;
-        }
 }
 static void del_fs_roots(struct btrfs_fs_info *fs_info)
@@ -2228,7 +2222,6 @@ int open_ctree(struct super_block *sb,
        atomic_set(&fs_info->scrubs_paused, 0);
        atomic_set(&fs_info->scrub_cancel_req, 0);
        init_waitqueue_head(&fs_info->scrub_pause_wait);
-        init_rwsem(&fs_info->scrub_super_lock);
        fs_info->scrub_workers_refcnt = 0;
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
        fs_info->check_integrity_print_mask = 0;
@@ -2270,7 +2263,7 @@ int open_ctree(struct super_block *sb,
               sizeof(struct btrfs_key));
        set_bit(BTRFS_INODE_DUMMY,
                &BTRFS_I(fs_info->btree_inode)->runtime_flags);
-        insert_inode_hash(fs_info->btree_inode);
+        btrfs_insert_inode_hash(fs_info->btree_inode);
        spin_lock_init(&fs_info->block_group_cache_lock);
        fs_info->block_group_cache_tree = RB_ROOT;
@@ -2668,6 +2661,7 @@ retry_root_backup:
        btrfs_set_root_node(&tree_root->root_item, tree_root->node);
        tree_root->commit_root = btrfs_root_node(tree_root);
+        btrfs_set_root_refs(&tree_root->root_item, 1);
        location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
        location.type = BTRFS_ROOT_ITEM_KEY;
@@ -3415,6 +3409,7 @@ static int write_all_supers(struct btrfs_root *root, int max_mirrors)
        if (total_errors > max_errors) {
                printk(KERN_ERR "btrfs: %d errors while writing supers\n",
                       total_errors);
+                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
                /* FUA is masked off if unsupported and can't be the reason */
                btrfs_error(root->fs_info, -EIO,
@@ -3445,10 +3440,7 @@ static int write_all_supers(struct btrfs_root *root, int max_mirrors)
 int write_ctree_super(struct btrfs_trans_handle *trans,
                      struct btrfs_root *root, int max_mirrors)
 {
-        int ret;
+        return write_all_supers(root, max_mirrors);
-        ret = write_all_supers(root, max_mirrors);
-        return ret;
 }
 /* Drop a fs root from the radix tree and free it. */
@@ -3525,7 +3517,6 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
 int btrfs_commit_super(struct btrfs_root *root)
 {
        struct btrfs_trans_handle *trans;
-        int ret;
        mutex_lock(&root->fs_info->cleaner_mutex);
        btrfs_run_delayed_iputs(root);
@@ -3539,25 +3530,7 @@ int btrfs_commit_super(struct btrfs_root *root)
        trans = btrfs_join_transaction(root);
        if (IS_ERR(trans))
                return PTR_ERR(trans);
-        ret = btrfs_commit_transaction(trans, root);
+        return btrfs_commit_transaction(trans, root);
-        if (ret)
-                return ret;
-        /* run commit again to drop the original snapshot */
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
-        ret = btrfs_commit_transaction(trans, root);
-        if (ret)
-                return ret;
-        ret = btrfs_write_and_wait_transaction(NULL, root);
-        if (ret) {
-                btrfs_error(root->fs_info, ret,
-                            "Failed to sync btree inode to disk.");
-                return ret;
-        }
-        ret = write_ctree_super(NULL, root, 0);
-        return ret;
 }
 int close_ctree(struct btrfs_root *root)
@@ -3611,12 +3584,12 @@ int close_ctree(struct btrfs_root *root)
                       percpu_counter_sum(&fs_info->delalloc_bytes));
        }
+        del_fs_roots(fs_info);
        btrfs_free_block_groups(fs_info);
        btrfs_stop_all_workers(fs_info);
-        del_fs_roots(fs_info);
        free_root_pointers(fs_info, 1);
        iput(fs_info->btree_inode);
@@ -3666,10 +3639,20 @@ int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
 void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
 {
-        struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
+        struct btrfs_root *root;
        u64 transid = btrfs_header_generation(buf);
        int was_dirty;
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+        /*
+         * This is a fast path so only do this check if we have sanity tests
+         * enabled.  Normal people shouldn't be marking dummy buffers as dirty
+         * outside of the sanity tests.
+         */
+        if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &buf->bflags)))
+                return;
+#endif
+        root = BTRFS_I(buf->pages[0]->mapping->host)->root;
        btrfs_assert_tree_locked(buf);
        if (transid != root->fs_info->generation)
                WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
@@ -3799,7 +3782,8 @@ static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
        while (!list_empty(&splice)) {
                root = list_first_entry(&splice, struct btrfs_root,
                                        ordered_root);
-                list_del_init(&root->ordered_root);
+                list_move_tail(&root->ordered_root,
+                               &fs_info->ordered_roots);
                btrfs_destroy_ordered_extents(root);
@@ -3877,24 +3861,6 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
        return ret;
 }
-static void btrfs_evict_pending_snapshots(struct btrfs_transaction *t)
-{
-        struct btrfs_pending_snapshot *snapshot;
-        struct list_head splice;
-        INIT_LIST_HEAD(&splice);
-        list_splice_init(&t->pending_snapshots, &splice);
-        while (!list_empty(&splice)) {
-                snapshot = list_entry(splice.next,
-                                      struct btrfs_pending_snapshot,
-                                      list);
-                snapshot->error = -ECANCELED;
-                list_del_init(&snapshot->list);
-        }
-}
 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
 {
        struct btrfs_inode *btrfs_inode;
@@ -4024,15 +3990,13 @@ again:
 void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
                                   struct btrfs_root *root)
 {
+        btrfs_destroy_ordered_operations(cur_trans, root);
        btrfs_destroy_delayed_refs(cur_trans, root);
-        btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
-                                cur_trans->dirty_pages.dirty_bytes);
        cur_trans->state = TRANS_STATE_COMMIT_START;
        wake_up(&root->fs_info->transaction_blocked_wait);
-        btrfs_evict_pending_snapshots(cur_trans);
        cur_trans->state = TRANS_STATE_UNBLOCKED;
        wake_up(&root->fs_info->transaction_wait);
@@ -4056,63 +4020,51 @@ void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
 static int btrfs_cleanup_transaction(struct btrfs_root *root)
 {
        struct btrfs_transaction *t;
-        LIST_HEAD(list);
        mutex_lock(&root->fs_info->transaction_kthread_mutex);
        spin_lock(&root->fs_info->trans_lock);
-        list_splice_init(&root->fs_info->trans_list, &list);
+        while (!list_empty(&root->fs_info->trans_list)) {
-        root->fs_info->running_transaction = NULL;
+                t = list_first_entry(&root->fs_info->trans_list,
-        spin_unlock(&root->fs_info->trans_lock);
+                                     struct btrfs_transaction, list);
+                if (t->state >= TRANS_STATE_COMMIT_START) {
-        while (!list_empty(&list)) {
+                        atomic_inc(&t->use_count);
-                t = list_entry(list.next, struct btrfs_transaction, list);
+                        spin_unlock(&root->fs_info->trans_lock);
+                        btrfs_wait_for_commit(root, t->transid);
-                btrfs_destroy_ordered_operations(t, root);
+                        btrfs_put_transaction(t);
+                        spin_lock(&root->fs_info->trans_lock);
-                btrfs_destroy_all_ordered_extents(root->fs_info);
+                        continue;
+                }
-                btrfs_destroy_delayed_refs(t, root);
+                if (t == root->fs_info->running_transaction) {
+                        t->state = TRANS_STATE_COMMIT_DOING;
-                /*
+                        spin_unlock(&root->fs_info->trans_lock);
-                 *  FIXME: cleanup wait for commit
+                        /*
-                 *  We needn't acquire the lock here, because we are during
+                         * We wait for 0 num_writers since we don't hold a trans
-                 *  the umount, there is no other task which will change it.
+                         * handle open currently for this transaction.
-                 */
+                         */
-                t->state = TRANS_STATE_COMMIT_START;
+                        wait_event(t->writer_wait,
-                smp_mb();
+                                   atomic_read(&t->num_writers) == 0);
-                if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
+                } else {
-                        wake_up(&root->fs_info->transaction_blocked_wait);
+                        spin_unlock(&root->fs_info->trans_lock);
+                }
-                btrfs_evict_pending_snapshots(t);
+                btrfs_cleanup_one_transaction(t, root);
-                t->state = TRANS_STATE_UNBLOCKED;
-                smp_mb();
-                if (waitqueue_active(&root->fs_info->transaction_wait))
-                        wake_up(&root->fs_info->transaction_wait);
-                btrfs_destroy_delayed_inodes(root);
-                btrfs_assert_delayed_root_empty(root);
-                btrfs_destroy_all_delalloc_inodes(root->fs_info);
-                btrfs_destroy_marked_extents(root, &t->dirty_pages,
-                                             EXTENT_DIRTY);
-                btrfs_destroy_pinned_extent(root,
-                                            root->fs_info->pinned_extents);
-                t->state = TRANS_STATE_COMPLETED;
-                smp_mb();
-                if (waitqueue_active(&t->commit_wait))
-                        wake_up(&t->commit_wait);
-                atomic_set(&t->use_count, 0);
+                spin_lock(&root->fs_info->trans_lock);
+                if (t == root->fs_info->running_transaction)
+                        root->fs_info->running_transaction = NULL;
                list_del_init(&t->list);
-                memset(t, 0, sizeof(*t));
+                spin_unlock(&root->fs_info->trans_lock);
-                kmem_cache_free(btrfs_transaction_cachep, t);
-        }
+                btrfs_put_transaction(t);
+                trace_btrfs_transaction_commit(root);
+                spin_lock(&root->fs_info->trans_lock);
+        }
+        spin_unlock(&root->fs_info->trans_lock);
+        btrfs_destroy_all_ordered_extents(root->fs_info);
+        btrfs_destroy_delayed_inodes(root);
+        btrfs_assert_delayed_root_empty(root);
+        btrfs_destroy_pinned_extent(root, root->fs_info->pinned_extents);
+        btrfs_destroy_all_delalloc_inodes(root->fs_info);
        mutex_unlock(&root->fs_info->transaction_kthread_mutex);
        return 0;
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index b71acd6e1e5b..53059df350f8 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -68,8 +68,17 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
 int btrfs_init_fs_root(struct btrfs_root *root);
 int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
                         struct btrfs_root *root);
-struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
-                                              struct btrfs_key *location);
+struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
+                                     struct btrfs_key *key,
+                                     bool check_ref);
+static inline struct btrfs_root *
+btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
+                           struct btrfs_key *location)
+{
+        return btrfs_get_fs_root(fs_info, location, true);
+}
 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info);
 void btrfs_btree_balance_dirty(struct btrfs_root *root);
 void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root);
@@ -77,6 +86,10 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
                                 struct btrfs_root *root);
 void btrfs_free_fs_root(struct btrfs_root *root);
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+struct btrfs_root *btrfs_alloc_dummy_root(void);
+#endif
 /*
 * This function is used to grab the root, and avoid it is freed when we
 * access it. But it doesn't ensure that the tree is not dropped.
diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index 4b8691607373..41422a3de8ed 100644
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -5,7 +5,6 @@
 #include "btrfs_inode.h"
 #include "print-tree.h"
 #include "export.h"
-#include "compat.h"
 #define BTRFS_FID_SIZE_NON_CONNECTABLE (offsetof(struct btrfs_fid, \
                                                 parent_objectid) / 4)
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index cfb3cf711b34..45d98d01028f 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -25,7 +25,6 @@
 #include <linux/slab.h>
 #include <linux/ratelimit.h>
 #include <linux/percpu_counter.h>
-#include "compat.h"
 #include "hash.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -1551,9 +1550,8 @@ again:
        if (ret && !insert) {
                err = -ENOENT;
                goto out;
-        } else if (ret) {
+        } else if (WARN_ON(ret)) {
                err = -EIO;
-                WARN_ON(1);
                goto out;
        }
@@ -1979,7 +1977,6 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
        struct btrfs_extent_item *item;
        u64 refs;
        int ret;
-        int err = 0;
        path = btrfs_alloc_path();
        if (!path)
@@ -1992,13 +1989,8 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
                                           path, bytenr, num_bytes, parent,
                                           root_objectid, owner, offset,
                                           refs_to_add, extent_op);
-        if (ret == 0)
+        if (ret != -EAGAIN)
-                goto out;
-        if (ret != -EAGAIN) {
-                err = ret;
                goto out;
-        }
        leaf = path->nodes[0];
        item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
@@ -2021,7 +2013,7 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
                btrfs_abort_transaction(trans, root, ret);
 out:
        btrfs_free_path(path);
-        return err;
+        return ret;
 }
 static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
@@ -2137,15 +2129,28 @@ again:
        }
        if (ret > 0) {
                if (metadata) {
-                        btrfs_release_path(path);
+                        if (path->slots[0] > 0) {
-                        metadata = 0;
+                                path->slots[0]--;
+                                btrfs_item_key_to_cpu(path->nodes[0], &key,
+                                                      path->slots[0]);
+                                if (key.objectid == node->bytenr &&
+                                    key.type == BTRFS_EXTENT_ITEM_KEY &&
+                                    key.offset == node->num_bytes)
+                                        ret = 0;
+                        }
+                        if (ret > 0) {
+                                btrfs_release_path(path);
+                                metadata = 0;
-                        key.offset = node->num_bytes;
+                                key.objectid = node->bytenr;
-                        key.type = BTRFS_EXTENT_ITEM_KEY;
+                                key.offset = node->num_bytes;
-                        goto again;
+                                key.type = BTRFS_EXTENT_ITEM_KEY;
+                                goto again;
+                        }
+                } else {
+                        err = -EIO;
+                        goto out;
                }
-                err = -EIO;
-                goto out;
        }
        leaf = path->nodes[0];
@@ -2234,8 +2239,12 @@ static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
 {
        int ret = 0;
-        if (trans->aborted)
+        if (trans->aborted) {
+                if (insert_reserved)
+                        btrfs_pin_extent(root, node->bytenr,
+                                         node->num_bytes, 1);
                return 0;
+        }
        if (btrfs_delayed_ref_is_head(node)) {
                struct btrfs_delayed_ref_head *head;
@@ -2411,6 +2420,14 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                                btrfs_free_delayed_extent_op(extent_op);
                                if (ret) {
+                                        /*
+                                         * Need to reset must_insert_reserved if
+                                         * there was an error so the abort stuff
+                                         * can cleanup the reserved space
+                                         * properly.
+                                         */
+                                        if (must_insert_reserved)
+                                                locked_ref->must_insert_reserved = 1;
                                        btrfs_debug(fs_info, "run_delayed_extent_op returned %d", ret);
                                        spin_lock(&delayed_refs->lock);
                                        btrfs_delayed_ref_unlock(locked_ref);
@@ -3197,8 +3214,7 @@ again:
                if (ret)
                        goto out_put;
-                ret = btrfs_truncate_free_space_cache(root, trans, path,
+                ret = btrfs_truncate_free_space_cache(root, trans, inode);
-                                                      inode);
                if (ret)
                        goto out_put;
        }
@@ -3318,10 +3334,9 @@ again:
                last = cache->key.objectid + cache->key.offset;
                err = write_one_cache_group(trans, root, path, cache);
+                btrfs_put_block_group(cache);
                if (err) /* File system offline */
                        goto out;
-                btrfs_put_block_group(cache);
        }
        while (1) {
@@ -3605,10 +3620,9 @@ int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
        /* make sure bytes are sectorsize aligned */
        bytes = ALIGN(bytes, root->sectorsize);
-        if (root == root->fs_info->tree_root ||
+        if (btrfs_is_free_space_inode(inode)) {
-            BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID) {
-                alloc_chunk = 0;
                committed = 1;
+                ASSERT(current->journal_info);
        }
        data_sinfo = fs_info->data_sinfo;
@@ -3636,6 +3650,16 @@ again:
                        spin_unlock(&data_sinfo->lock);
 alloc:
                        alloc_target = btrfs_get_alloc_profile(root, 1);
+                        /*
+                         * It is ugly that we don't call nolock join
+                         * transaction for the free space inode case here.
+                         * But it is safe because we only do the data space
+                         * reservation for the free space cache in the
+                         * transaction context, the common join transaction
+                         * just increase the counter of the current transaction
+                         * handler, doesn't try to acquire the trans_lock of
+                         * the fs.
+                         */
                        trans = btrfs_join_transaction(root);
                        if (IS_ERR(trans))
                                return PTR_ERR(trans);
@@ -3681,6 +3705,9 @@ commit_trans:
                        goto again;
                }
+                trace_btrfs_space_reservation(root->fs_info,
+                                              "space_info:enospc",
+                                              data_sinfo->flags, bytes, 1);
                return -ENOSPC;
        }
        data_sinfo->bytes_may_use += bytes;
@@ -3925,7 +3952,6 @@ static int can_overcommit(struct btrfs_root *root,
        u64 space_size;
        u64 avail;
        u64 used;
-        u64 to_add;
        used = space_info->bytes_used + space_info->bytes_reserved +
                space_info->bytes_pinned + space_info->bytes_readonly;
@@ -3959,25 +3985,17 @@ static int can_overcommit(struct btrfs_root *root,
                       BTRFS_BLOCK_GROUP_RAID10))
                avail >>= 1;
-        to_add = space_info->total_bytes;
        /*
         * If we aren't flushing all things, let us overcommit up to
         * 1/2th of the space. If we can flush, don't let us overcommit
         * too much, let it overcommit up to 1/8 of the space.
         */
        if (flush == BTRFS_RESERVE_FLUSH_ALL)
-                to_add >>= 3;
+                avail >>= 3;
        else
-                to_add >>= 1;
+                avail >>= 1;
-        /*
-         * Limit the overcommit to the amount of free space we could possibly
-         * allocate for chunks.
-         */
-        to_add = min(avail, to_add);
-        if (used + bytes < space_info->total_bytes + to_add)
+        if (used + bytes < space_info->total_bytes + avail)
                return 1;
        return 0;
 }
@@ -3998,12 +4016,26 @@ static void btrfs_writeback_inodes_sb_nr(struct btrfs_root *root,
                 * the filesystem is readonly(all dirty pages are written to
                 * the disk).
                 */
-                btrfs_start_all_delalloc_inodes(root->fs_info, 0);
+                btrfs_start_delalloc_roots(root->fs_info, 0);
                if (!current->journal_info)
-                        btrfs_wait_all_ordered_extents(root->fs_info, 0);
+                        btrfs_wait_ordered_roots(root->fs_info, -1);
        }
 }
+static inline int calc_reclaim_items_nr(struct btrfs_root *root, u64 to_reclaim)
+{
+        u64 bytes;
+        int nr;
+        bytes = btrfs_calc_trans_metadata_size(root, 1);
+        nr = (int)div64_u64(to_reclaim, bytes);
+        if (!nr)
+                nr = 1;
+        return nr;
+}
+#define EXTENT_SIZE_PER_ITEM    (256 * 1024)
 /*
 * shrink metadata reservation for delalloc
 */
@@ -4016,24 +4048,30 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
        u64 delalloc_bytes;
        u64 max_reclaim;
        long time_left;
-        unsigned long nr_pages = (2 * 1024 * 1024) >> PAGE_CACHE_SHIFT;
+        unsigned long nr_pages;
-        int loops = 0;
+        int loops;
+        int items;
        enum btrfs_reserve_flush_enum flush;
+        /* Calc the number of the pages we need flush for space reservation */
+        items = calc_reclaim_items_nr(root, to_reclaim);
+        to_reclaim = items * EXTENT_SIZE_PER_ITEM;
        trans = (struct btrfs_trans_handle *)current->journal_info;
        block_rsv = &root->fs_info->delalloc_block_rsv;
        space_info = block_rsv->space_info;
-        smp_mb();
        delalloc_bytes = percpu_counter_sum_positive(
                                                &root->fs_info->delalloc_bytes);
        if (delalloc_bytes == 0) {
                if (trans)
                        return;
-                btrfs_wait_all_ordered_extents(root->fs_info, 0);
+                if (wait_ordered)
+                        btrfs_wait_ordered_roots(root->fs_info, items);
                return;
        }
+        loops = 0;
        while (delalloc_bytes && loops < 3) {
                max_reclaim = min(delalloc_bytes, to_reclaim);
                nr_pages = max_reclaim >> PAGE_CACHE_SHIFT;
@@ -4042,9 +4080,19 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
                 * We need to wait for the async pages to actually start before
                 * we do anything.
                 */
-                wait_event(root->fs_info->async_submit_wait,
+                max_reclaim = atomic_read(&root->fs_info->async_delalloc_pages);
-                           !atomic_read(&root->fs_info->async_delalloc_pages));
+                if (!max_reclaim)
+                        goto skip_async;
+                if (max_reclaim <= nr_pages)
+                        max_reclaim = 0;
+                else
+                        max_reclaim -= nr_pages;
+                wait_event(root->fs_info->async_submit_wait,
+                           atomic_read(&root->fs_info->async_delalloc_pages) <=
+                           (int)max_reclaim);
+skip_async:
                if (!trans)
                        flush = BTRFS_RESERVE_FLUSH_ALL;
                else
@@ -4058,13 +4106,12 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
                loops++;
                if (wait_ordered && !trans) {
-                        btrfs_wait_all_ordered_extents(root->fs_info, 0);
+                        btrfs_wait_ordered_roots(root->fs_info, items);
                } else {
                        time_left = schedule_timeout_killable(1);
                        if (time_left)
                                break;
                }
-                smp_mb();
                delalloc_bytes = percpu_counter_sum_positive(
                                                &root->fs_info->delalloc_bytes);
        }
@@ -4149,16 +4196,11 @@ static int flush_space(struct btrfs_root *root,
        switch (state) {
        case FLUSH_DELAYED_ITEMS_NR:
        case FLUSH_DELAYED_ITEMS:
-                if (state == FLUSH_DELAYED_ITEMS_NR) {
+                if (state == FLUSH_DELAYED_ITEMS_NR)
-                        u64 bytes = btrfs_calc_trans_metadata_size(root, 1);
+                        nr = calc_reclaim_items_nr(root, num_bytes) * 2;
+                else
-                        nr = (int)div64_u64(num_bytes, bytes);
-                        if (!nr)
-                                nr = 1;
-                        nr *= 2;
-                } else {
                        nr = -1;
-                }
                trans = btrfs_join_transaction(root);
                if (IS_ERR(trans)) {
                        ret = PTR_ERR(trans);
@@ -4341,6 +4383,10 @@ out:
                    !block_rsv_use_bytes(global_rsv, orig_bytes))
                        ret = 0;
        }
+        if (ret == -ENOSPC)
+                trace_btrfs_space_reservation(root->fs_info,
+                                              "space_info:enospc",
+                                              space_info->flags, orig_bytes, 1);
        if (flushing) {
                spin_lock(&space_info->lock);
                space_info->flush = 0;
@@ -4465,7 +4511,6 @@ static void block_rsv_release_bytes(struct btrfs_fs_info *fs_info,
                        space_info->bytes_may_use -= num_bytes;
                        trace_btrfs_space_reservation(fs_info, "space_info",
                                        space_info->flags, num_bytes, 0);
-                        space_info->reservation_progress++;
                        spin_unlock(&space_info->lock);
                }
        }
@@ -4666,7 +4711,6 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
                sinfo->bytes_may_use -= num_bytes;
                trace_btrfs_space_reservation(fs_info, "space_info",
                                      sinfo->flags, num_bytes, 0);
-                sinfo->reservation_progress++;
                block_rsv->reserved = block_rsv->size;
                block_rsv->full = 1;
        }
@@ -4997,7 +5041,7 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
                mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
        if (to_reserve)
-                trace_btrfs_space_reservation(root->fs_info,"delalloc",
+                trace_btrfs_space_reservation(root->fs_info, "delalloc",
                                              btrfs_ino(inode), to_reserve, 1);
        block_rsv_add_bytes(block_rsv, to_reserve, 1);
@@ -5275,6 +5319,8 @@ static int pin_down_extent(struct btrfs_root *root,
        set_extent_dirty(root->fs_info->pinned_extents, bytenr,
                         bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
+        if (reserved)
+                trace_btrfs_reserved_extent_free(root, bytenr, num_bytes);
        return 0;
 }
@@ -5446,7 +5492,6 @@ static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache,
                        space_info->bytes_readonly += num_bytes;
                cache->reserved -= num_bytes;
                space_info->bytes_reserved -= num_bytes;
-                space_info->reservation_progress++;
        }
        spin_unlock(&cache->lock);
        spin_unlock(&space_info->lock);
@@ -5730,9 +5775,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                        }
                        extent_slot = path->slots[0];
                }
-        } else if (ret == -ENOENT) {
+        } else if (WARN_ON(ret == -ENOENT)) {
                btrfs_print_leaf(extent_root, path->nodes[0]);
-                WARN_ON(1);
                btrfs_err(info,
                        "unable to find ref byte nr %llu parent %llu root %llu  owner %llu offset %llu",
                        bytenr, parent, root_objectid, owner_objectid,
@@ -5979,6 +6023,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
                btrfs_add_free_space(cache, buf->start, buf->len);
                btrfs_update_reserved_bytes(cache, buf->len, RESERVE_FREE);
+                trace_btrfs_reserved_extent_free(root, buf->start, buf->len);
                pin = 0;
        }
 out:
@@ -6117,10 +6162,13 @@ enum btrfs_loop_type {
 /*
 * walks the btree of allocated extents and find a hole of a given size.
 * The key ins is changed to record the hole:
- * ins->objectid == block start
+ * ins->objectid == start position
 * ins->flags = BTRFS_EXTENT_ITEM_KEY
- * ins->offset == number of blocks
+ * ins->offset == the size of the hole.
 * Any available blocks before search_start are skipped.
+ *
+ * If there is no suitable free space, we will record the max size of
+ * the free space extent currently.
 */
 static noinline int find_free_extent(struct btrfs_root *orig_root,
                                     u64 num_bytes, u64 empty_size,
@@ -6133,6 +6181,7 @@ static noinline int find_free_extent(struct btrfs_root *orig_root,
        struct btrfs_block_group_cache *block_group = NULL;
        struct btrfs_block_group_cache *used_block_group;
        u64 search_start = 0;
+        u64 max_extent_size = 0;
        int empty_cluster = 2 * 1024 * 1024;
        struct btrfs_space_info *space_info;
        int loop = 0;
@@ -6292,7 +6341,10 @@ have_block_group:
                                btrfs_get_block_group(used_block_group);
                        offset = btrfs_alloc_from_cluster(used_block_group,
-                          last_ptr, num_bytes, used_block_group->key.objectid);
+                                                last_ptr,
+                                                num_bytes,
+                                                used_block_group->key.objectid,
+                                                &max_extent_size);
                        if (offset) {
                                /* we have a block, we're done */
                                spin_unlock(&last_ptr->refill_lock);
@@ -6355,8 +6407,10 @@ refill_cluster:
                                 * cluster
                                 */
                                offset = btrfs_alloc_from_cluster(block_group,
-                                                  last_ptr, num_bytes,
+                                                        last_ptr,
-                                                  search_start);
+                                                        num_bytes,
+                                                        search_start,
+                                                        &max_extent_size);
                                if (offset) {
                                        /* we found one, proceed */
                                        spin_unlock(&last_ptr->refill_lock);
@@ -6391,13 +6445,18 @@ unclustered_alloc:
                if (cached &&
                    block_group->free_space_ctl->free_space <
                    num_bytes + empty_cluster + empty_size) {
+                        if (block_group->free_space_ctl->free_space >
+                            max_extent_size)
+                                max_extent_size =
+                                        block_group->free_space_ctl->free_space;
                        spin_unlock(&block_group->free_space_ctl->tree_lock);
                        goto loop;
                }
                spin_unlock(&block_group->free_space_ctl->tree_lock);
                offset = btrfs_find_space_for_alloc(block_group, search_start,
-                                                    num_bytes, empty_size);
+                                                    num_bytes, empty_size,
+                                                    &max_extent_size);
                /*
                 * If we didn't find a chunk, and we haven't failed on this
                 * block group before, and this block group is in the middle of
@@ -6515,7 +6574,8 @@ loop:
                ret = 0;
        }
 out:
+        if (ret == -ENOSPC)
+                ins->offset = max_extent_size;
        return ret;
 }
@@ -6573,8 +6633,8 @@ again:
                               flags);
        if (ret == -ENOSPC) {
-                if (!final_tried) {
+                if (!final_tried && ins->offset) {
-                        num_bytes = num_bytes >> 1;
+                        num_bytes = min(num_bytes >> 1, ins->offset);
                        num_bytes = round_down(num_bytes, root->sectorsize);
                        num_bytes = max(num_bytes, min_alloc_size);
                        if (num_bytes == min_alloc_size)
@@ -6591,8 +6651,6 @@ again:
                }
        }
-        trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
        return ret;
 }
@@ -6704,6 +6762,7 @@ static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
                        ins->objectid, ins->offset);
                BUG();
        }
+        trace_btrfs_reserved_extent_alloc(root, ins->objectid, ins->offset);
        return ret;
 }
@@ -6728,13 +6787,18 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
                size += sizeof(*block_info);
        path = btrfs_alloc_path();
-        if (!path)
+        if (!path) {
+                btrfs_free_and_pin_reserved_extent(root, ins->objectid,
+                                                   root->leafsize);
                return -ENOMEM;
+        }
        path->leave_spinning = 1;
        ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
                                      ins, size);
        if (ret) {
+                btrfs_free_and_pin_reserved_extent(root, ins->objectid,
+                                                   root->leafsize);
                btrfs_free_path(path);
                return ret;
        }
@@ -6776,6 +6840,8 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
                        ins->objectid, ins->offset);
                BUG();
        }
+        trace_btrfs_reserved_extent_alloc(root, ins->objectid, root->leafsize);
        return ret;
 }
@@ -7980,7 +8046,7 @@ u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo)
        spin_lock(&sinfo->lock);
-        for(i = 0; i < BTRFS_NR_RAID_TYPES; i++)
+        for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
                if (!list_empty(&sinfo->block_groups[i]))
                        free_bytes += __btrfs_get_ro_block_group_free_space(
                                                &sinfo->block_groups[i]);
@@ -8268,15 +8334,14 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)
        release_global_block_rsv(info);
-        while(!list_empty(&info->space_info)) {
+        while (!list_empty(&info->space_info)) {
                space_info = list_entry(info->space_info.next,
                                        struct btrfs_space_info,
                                        list);
                if (btrfs_test_opt(info->tree_root, ENOSPC_DEBUG)) {
-                        if (space_info->bytes_pinned > 0 ||
+                        if (WARN_ON(space_info->bytes_pinned > 0 ||
                            space_info->bytes_reserved > 0 ||
-                            space_info->bytes_may_use > 0) {
+                            space_info->bytes_may_use > 0)) {
-                                WARN_ON(1);
                                dump_space_info(space_info, 0, 0);
                        }
                }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 09582b81640c..8e457fca0a0b 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -13,13 +13,13 @@
 #include <linux/cleancache.h>
 #include "extent_io.h"
 #include "extent_map.h"
-#include "compat.h"
 #include "ctree.h"
 #include "btrfs_inode.h"
 #include "volumes.h"
 #include "check-integrity.h"
 #include "locking.h"
 #include "rcu-string.h"
+#include "backref.h"
 static struct kmem_cache *extent_state_cache;
 static struct kmem_cache *extent_buffer_cache;
@@ -145,8 +145,16 @@ int __init extent_io_init(void)
                                     offsetof(struct btrfs_io_bio, bio));
        if (!btrfs_bioset)
                goto free_buffer_cache;
+        if (bioset_integrity_create(btrfs_bioset, BIO_POOL_SIZE))
+                goto free_bioset;
        return 0;
+free_bioset:
+        bioset_free(btrfs_bioset);
+        btrfs_bioset = NULL;
 free_buffer_cache:
        kmem_cache_destroy(extent_buffer_cache);
        extent_buffer_cache = NULL;
@@ -1481,11 +1489,11 @@ static noinline u64 find_delalloc_range(struct extent_io_tree *tree,
                *end = state->end;
                cur_start = state->end + 1;
                node = rb_next(node);
-                if (!node)
-                        break;
                total_bytes += state->end - state->start + 1;
                if (total_bytes >= max_bytes)
                        break;
+                if (!node)
+                        break;
        }
 out:
        spin_unlock(&tree->lock);
@@ -1589,11 +1597,10 @@ done:
 *
 * 1 is returned if we find something, 0 if nothing was in the tree
 */
-static noinline u64 find_lock_delalloc_range(struct inode *inode,
+STATIC u64 find_lock_delalloc_range(struct inode *inode,
-                                             struct extent_io_tree *tree,
+                                    struct extent_io_tree *tree,
-                                             struct page *locked_page,
+                                    struct page *locked_page, u64 *start,
-                                             u64 *start, u64 *end,
+                                    u64 *end, u64 max_bytes)
-                                             u64 max_bytes)
 {
        u64 delalloc_start;
        u64 delalloc_end;
@@ -1612,7 +1619,7 @@ again:
                *start = delalloc_start;
                *end = delalloc_end;
                free_extent_state(cached_state);
-                return found;
+                return 0;
        }
        /*
@@ -1625,10 +1632,9 @@ again:
        /*
         * make sure to limit the number of pages we try to lock down
-         * if we're looping.
         */
-        if (delalloc_end + 1 - delalloc_start > max_bytes && loops)
+        if (delalloc_end + 1 - delalloc_start > max_bytes)
-                delalloc_end = delalloc_start + PAGE_CACHE_SIZE - 1;
+                delalloc_end = delalloc_start + max_bytes - 1;
        /* step two, lock all the pages after the page that has start */
        ret = lock_delalloc_pages(inode, locked_page,
@@ -1639,8 +1645,7 @@ again:
                 */
                free_extent_state(cached_state);
                if (!loops) {
-                        unsigned long offset = (*start) & (PAGE_CACHE_SIZE - 1);
+                        max_bytes = PAGE_CACHE_SIZE;
-                        max_bytes = PAGE_CACHE_SIZE - offset;
                        loops = 1;
                        goto again;
                } else {
@@ -1734,10 +1739,8 @@ u64 count_range_bits(struct extent_io_tree *tree,
        u64 last = 0;
        int found = 0;
-        if (search_end <= cur_start) {
+        if (WARN_ON(search_end <= cur_start))
-                WARN_ON(1);
                return 0;
-        }
        spin_lock(&tree->lock);
        if (cur_start == 0 && bits == EXTENT_DIRTY) {
@@ -1977,6 +1980,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
        struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
        int ret;
+        ASSERT(!(fs_info->sb->s_flags & MS_RDONLY));
        BUG_ON(!mirror_num);
        /* we can't repair anything in raid56 yet */
@@ -2033,6 +2037,9 @@ int repair_eb_io_failure(struct btrfs_root *root, struct extent_buffer *eb,
        unsigned long i, num_pages = num_extent_pages(eb->start, eb->len);
        int ret = 0;
+        if (root->fs_info->sb->s_flags & MS_RDONLY)
+                return -EROFS;
        for (i = 0; i < num_pages; i++) {
                struct page *p = extent_buffer_page(eb, i);
                ret = repair_io_failure(root->fs_info, start, PAGE_CACHE_SIZE,
@@ -2054,12 +2061,12 @@ static int clean_io_failure(u64 start, struct page *page)
        u64 private;
        u64 private_failure;
        struct io_failure_record *failrec;
-        struct btrfs_fs_info *fs_info;
+        struct inode *inode = page->mapping->host;
+        struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
        struct extent_state *state;
        int num_copies;
        int did_repair = 0;
        int ret;
-        struct inode *inode = page->mapping->host;
        private = 0;
        ret = count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
@@ -2082,6 +2089,8 @@ static int clean_io_failure(u64 start, struct page *page)
                did_repair = 1;
                goto out;
        }
+        if (fs_info->sb->s_flags & MS_RDONLY)
+                goto out;
        spin_lock(&BTRFS_I(inode)->io_tree.lock);
        state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
@@ -2091,7 +2100,6 @@ static int clean_io_failure(u64 start, struct page *page)
        if (state && state->start <= failrec->start &&
            state->end >= failrec->start + failrec->len - 1) {
-                fs_info = BTRFS_I(inode)->root->fs_info;
                num_copies = btrfs_num_copies(fs_info, failrec->logical,
                                              failrec->len);
                if (num_copies > 1)  {
@@ -3563,9 +3571,8 @@ retry:
                         * but no sense in crashing the users box for something
                         * we can survive anyway.
                         */
-                        if (!eb) {
+                        if (WARN_ON(!eb)) {
                                spin_unlock(&mapping->private_lock);
-                                WARN_ON(1);
                                continue;
                        }
@@ -4032,7 +4039,7 @@ static struct extent_map *get_extent_skip_holes(struct inode *inode,
        if (offset >= last)
                return NULL;
-        while(1) {
+        while (1) {
                len = last - offset;
                if (len == 0)
                        break;
@@ -4056,6 +4063,19 @@ static struct extent_map *get_extent_skip_holes(struct inode *inode,
        return NULL;
 }
+static noinline int count_ext_ref(u64 inum, u64 offset, u64 root_id, void *ctx)
+{
+        unsigned long cnt = *((unsigned long *)ctx);
+        cnt++;
+        *((unsigned long *)ctx) = cnt;
+        /* Now we're sure that the extent is shared. */
+        if (cnt > 1)
+                return 1;
+        return 0;
+}
 int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                __u64 start, __u64 len, get_extent_t *get_extent)
 {
@@ -4122,7 +4142,7 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                last = found_key.offset;
                last_for_get_extent = last + 1;
        }
-        btrfs_free_path(path);
+        btrfs_release_path(path);
        /*
         * we might have some extents allocated but more delalloc past those
@@ -4192,7 +4212,24 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                        flags |= (FIEMAP_EXTENT_DELALLOC |
                                  FIEMAP_EXTENT_UNKNOWN);
                } else {
+                        unsigned long ref_cnt = 0;
                        disko = em->block_start + offset_in_extent;
+                        /*
+                         * As btrfs supports shared space, this information
+                         * can be exported to userspace tools via
+                         * flag FIEMAP_EXTENT_SHARED.
+                         */
+                        ret = iterate_inodes_from_logical(
+                                        em->block_start,
+                                        BTRFS_I(inode)->root->fs_info,
+                                        path, count_ext_ref, &ref_cnt);
+                        if (ret < 0 && ret != -ENOENT)
+                                goto out_free;
+                        if (ref_cnt > 1)
+                                flags |= FIEMAP_EXTENT_SHARED;
                }
                if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags))
                        flags |= FIEMAP_EXTENT_ENCODED;
@@ -4224,6 +4261,7 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 out_free:
        free_extent_map(em);
 out:
+        btrfs_free_path(path);
        unlock_extent_cached(&BTRFS_I(inode)->io_tree, start, start + len - 1,
                             &cached_state, GFP_NOFS);
        return ret;
@@ -4449,6 +4487,23 @@ static void mark_extent_buffer_accessed(struct extent_buffer *eb)
        }
 }
+struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
+                                                        u64 start)
+{
+        struct extent_buffer *eb;
+        rcu_read_lock();
+        eb = radix_tree_lookup(&tree->buffer, start >> PAGE_CACHE_SHIFT);
+        if (eb && atomic_inc_not_zero(&eb->refs)) {
+                rcu_read_unlock();
+                mark_extent_buffer_accessed(eb);
+                return eb;
+        }
+        rcu_read_unlock();
+        return NULL;
+}
 struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
                                          u64 start, unsigned long len)
 {
@@ -4462,14 +4517,10 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
        int uptodate = 1;
        int ret;
-        rcu_read_lock();
-        eb = radix_tree_lookup(&tree->buffer, start >> PAGE_CACHE_SHIFT);
+        eb = find_extent_buffer(tree, start);
-        if (eb && atomic_inc_not_zero(&eb->refs)) {
+        if (eb)
-                rcu_read_unlock();
-                mark_extent_buffer_accessed(eb);
                return eb;
-        }
-        rcu_read_unlock();
        eb = __alloc_extent_buffer(tree, start, len, GFP_NOFS);
        if (!eb)
@@ -4528,24 +4579,17 @@ again:
        spin_lock(&tree->buffer_lock);
        ret = radix_tree_insert(&tree->buffer, start >> PAGE_CACHE_SHIFT, eb);
+        spin_unlock(&tree->buffer_lock);
+        radix_tree_preload_end();
        if (ret == -EEXIST) {
-                exists = radix_tree_lookup(&tree->buffer,
+                exists = find_extent_buffer(tree, start);
-                                                start >> PAGE_CACHE_SHIFT);
+                if (exists)
-                if (!atomic_inc_not_zero(&exists->refs)) {
+                        goto free_eb;
-                        spin_unlock(&tree->buffer_lock);
+                else
-                        radix_tree_preload_end();
-                        exists = NULL;
                        goto again;
-                }
-                spin_unlock(&tree->buffer_lock);
-                radix_tree_preload_end();
-                mark_extent_buffer_accessed(exists);
-                goto free_eb;
        }
        /* add one reference for the tree */
        check_buffer_tree_ref(eb);
-        spin_unlock(&tree->buffer_lock);
-        radix_tree_preload_end();
        /*
         * there is a race where release page may have
@@ -4576,23 +4620,6 @@ free_eb:
        return exists;
 }
-struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
-                                         u64 start, unsigned long len)
-{
-        struct extent_buffer *eb;
-        rcu_read_lock();
-        eb = radix_tree_lookup(&tree->buffer, start >> PAGE_CACHE_SHIFT);
-        if (eb && atomic_inc_not_zero(&eb->refs)) {
-                rcu_read_unlock();
-                mark_extent_buffer_accessed(eb);
-                return eb;
-        }
-        rcu_read_unlock();
-        return NULL;
-}
 static inline void btrfs_release_extent_buffer_rcu(struct rcu_head *head)
 {
        struct extent_buffer *eb =
@@ -5056,23 +5083,6 @@ void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
        }
 }
-static void move_pages(struct page *dst_page, struct page *src_page,
-                       unsigned long dst_off, unsigned long src_off,
-                       unsigned long len)
-{
-        char *dst_kaddr = page_address(dst_page);
-        if (dst_page == src_page) {
-                memmove(dst_kaddr + dst_off, dst_kaddr + src_off, len);
-        } else {
-                char *src_kaddr = page_address(src_page);
-                char *p = dst_kaddr + dst_off + len;
-                char *s = src_kaddr + src_off + len;
-                while (len--)
-                        *--p = *--s;
-        }
-}
 static inline bool areas_overlap(unsigned long src, unsigned long dst, unsigned long len)
 {
        unsigned long distance = (src > dst) ? src - dst : dst - src;
@@ -5183,7 +5193,7 @@ void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
                cur = min_t(unsigned long, len, src_off_in_page + 1);
                cur = min(cur, dst_off_in_page + 1);
-                move_pages(extent_buffer_page(dst, dst_i),
+                copy_pages(extent_buffer_page(dst, dst_i),
                           extent_buffer_page(dst, src_i),
                           dst_off_in_page - cur + 1,
                           src_off_in_page - cur + 1, cur);
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 6dbc645f1f3d..19620c58f096 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -271,7 +271,7 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
 struct extent_buffer *alloc_dummy_extent_buffer(u64 start, unsigned long len);
 struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src);
 struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
-                                         u64 start, unsigned long len);
+                                         u64 start);
 void free_extent_buffer(struct extent_buffer *eb);
 void free_extent_buffer_stale(struct extent_buffer *eb);
 #define WAIT_NONE       0
@@ -345,4 +345,10 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
 int end_extent_writepage(struct page *page, int err, u64 start, u64 end);
 int repair_eb_io_failure(struct btrfs_root *root, struct extent_buffer *eb,
                         int mirror_num);
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+noinline u64 find_lock_delalloc_range(struct inode *inode,
+                                      struct extent_io_tree *tree,
+                                      struct page *locked_page, u64 *start,
+                                      u64 *end, u64 max_bytes);
+#endif
 #endif
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index 61adc44b7805..93fba716d7f8 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -3,10 +3,10 @@
 #include <linux/rbtree.h>
-#define EXTENT_MAP_LAST_BYTE (u64)-4
+#define EXTENT_MAP_LAST_BYTE ((u64)-4)
-#define EXTENT_MAP_HOLE (u64)-3
+#define EXTENT_MAP_HOLE ((u64)-3)
-#define EXTENT_MAP_INLINE (u64)-2
+#define EXTENT_MAP_INLINE ((u64)-2)
-#define EXTENT_MAP_DELALLOC (u64)-1
+#define EXTENT_MAP_DELALLOC ((u64)-1)
 /* bits for the flags field */
 #define EXTENT_FLAG_PINNED 0 /* this entry not yet on disk, don't free it */
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 4f53159bdb9d..6f3848860283 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -329,6 +329,9 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
        u64 csum_end;
        u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
+        ASSERT(start == ALIGN(start, root->sectorsize) &&
+               (end + 1) == ALIGN(end + 1, root->sectorsize));
        path = btrfs_alloc_path();
        if (!path)
                return -ENOMEM;
@@ -846,10 +849,8 @@ insert:
        path->leave_spinning = 0;
        if (ret < 0)
                goto fail_unlock;
-        if (ret != 0) {
+        if (WARN_ON(ret != 0))
-                WARN_ON(1);
                goto fail_unlock;
-        }
        leaf = path->nodes[0];
 csum:
        item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index bc5072b2db53..82d0342763c5 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -39,7 +39,6 @@
 #include "print-tree.h"
 #include "tree-log.h"
 #include "locking.h"
-#include "compat.h"
 #include "volumes.h"
 static struct kmem_cache *btrfs_inode_defrag_cachep;
@@ -370,7 +369,7 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
        u64 root_objectid = 0;
        atomic_inc(&fs_info->defrag_running);
-        while(1) {
+        while (1) {
                /* Pause the auto defragger. */
                if (test_bit(BTRFS_FS_STATE_REMOUNTING,
                             &fs_info->fs_state))
@@ -1281,6 +1280,7 @@ again:
                }
                wait_on_page_writeback(pages[i]);
        }
+        faili = num_pages - 1;
        err = 0;
        if (start_pos < inode->i_size) {
                struct btrfs_ordered_extent *ordered;
@@ -1299,8 +1299,10 @@ again:
                                unlock_page(pages[i]);
                                page_cache_release(pages[i]);
                        }
-                        btrfs_wait_ordered_range(inode, start_pos,
+                        err = btrfs_wait_ordered_range(inode, start_pos,
-                                                 last_pos - start_pos);
+                                                       last_pos - start_pos);
+                        if (err)
+                                goto fail;
                        goto again;
                }
                if (ordered)
@@ -1809,8 +1811,13 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        atomic_inc(&root->log_batch);
        full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
                             &BTRFS_I(inode)->runtime_flags);
-        if (full_sync)
+        if (full_sync) {
-                btrfs_wait_ordered_range(inode, start, end - start + 1);
+                ret = btrfs_wait_ordered_range(inode, start, end - start + 1);
+                if (ret) {
+                        mutex_unlock(&inode->i_mutex);
+                        goto out;
+                }
+        }
        atomic_inc(&root->log_batch);
        /*
@@ -1859,8 +1866,8 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        ret = btrfs_log_dentry_safe(trans, root, dentry);
        if (ret < 0) {
-                mutex_unlock(&inode->i_mutex);
+                /* Fallthrough and commit/free transaction. */
-                goto out;
+                ret = 1;
        }
        /* we've logged all the items and now have a consistent
@@ -1876,27 +1883,20 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
        mutex_unlock(&inode->i_mutex);
        if (ret != BTRFS_NO_LOG_SYNC) {
-                if (ret > 0) {
+                if (!ret) {
-                        /*
-                         * If we didn't already wait for ordered extents we need
-                         * to do that now.
-                         */
-                        if (!full_sync)
-                                btrfs_wait_ordered_range(inode, start,
-                                                         end - start + 1);
-                        ret = btrfs_commit_transaction(trans, root);
-                } else {
                        ret = btrfs_sync_log(trans, root);
-                        if (ret == 0) {
+                        if (!ret) {
                                ret = btrfs_end_transaction(trans, root);
-                        } else {
+                                goto out;
-                                if (!full_sync)
-                                        btrfs_wait_ordered_range(inode, start,
-                                                                 end -
-                                                                 start + 1);
-                                ret = btrfs_commit_transaction(trans, root);
                        }
                }
+                if (!full_sync) {
+                        ret = btrfs_wait_ordered_range(inode, start,
+                                                       end - start + 1);
+                        if (ret)
+                                goto out;
+                }
+                ret = btrfs_commit_transaction(trans, root);
        } else {
                ret = btrfs_end_transaction(trans, root);
        }
@@ -2067,7 +2067,9 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
        bool same_page = ((offset >> PAGE_CACHE_SHIFT) ==
                          ((offset + len - 1) >> PAGE_CACHE_SHIFT));
-        btrfs_wait_ordered_range(inode, offset, len);
+        ret = btrfs_wait_ordered_range(inode, offset, len);
+        if (ret)
+                return ret;
        mutex_lock(&inode->i_mutex);
        /*
@@ -2136,8 +2138,12 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                        btrfs_put_ordered_extent(ordered);
                unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
                                     lockend, &cached_state, GFP_NOFS);
-                btrfs_wait_ordered_range(inode, lockstart,
+                ret = btrfs_wait_ordered_range(inode, lockstart,
-                                         lockend - lockstart + 1);
+                                               lockend - lockstart + 1);
+                if (ret) {
+                        mutex_unlock(&inode->i_mutex);
+                        return ret;
+                }
        }
        path = btrfs_alloc_path();
@@ -2308,7 +2314,10 @@ static long btrfs_fallocate(struct file *file, int mode,
         * wait for ordered IO before we have any locks.  We'll loop again
         * below with the locks held.
         */
-        btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);
+        ret = btrfs_wait_ordered_range(inode, alloc_start,
+                                       alloc_end - alloc_start);
+        if (ret)
+                goto out;
        locked_end = alloc_end - 1;
        while (1) {
@@ -2332,8 +2341,10 @@ static long btrfs_fallocate(struct file *file, int mode,
                         * we can't wait on the range with the transaction
                         * running or with the extent lock held
                         */
-                        btrfs_wait_ordered_range(inode, alloc_start,
+                        ret = btrfs_wait_ordered_range(inode, alloc_start,
-                                                 alloc_end - alloc_start);
+                                                       alloc_end - alloc_start);
+                        if (ret)
+                                goto out;
                } else {
                        if (ordered)
                                btrfs_put_ordered_extent(ordered);
@@ -2405,14 +2416,12 @@ out_reserve_fail:
 static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
 {
        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct extent_map *em;
+        struct extent_map *em = NULL;
        struct extent_state *cached_state = NULL;
        u64 lockstart = *offset;
        u64 lockend = i_size_read(inode);
        u64 start = *offset;
-        u64 orig_start = *offset;
        u64 len = i_size_read(inode);
-        u64 last_end = 0;
        int ret = 0;
        lockend = max_t(u64, root->sectorsize, lockend);
@@ -2429,89 +2438,35 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
        lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 0,
                         &cached_state);
-        /*
+        while (start < inode->i_size) {
-         * Delalloc is such a pain.  If we have a hole and we have pending
-         * delalloc for a portion of the hole we will get back a hole that
-         * exists for the entire range since it hasn't been actually written
-         * yet.  So to take care of this case we need to look for an extent just
-         * before the position we want in case there is outstanding delalloc
-         * going on here.
-         */
-        if (whence == SEEK_HOLE && start != 0) {
-                if (start <= root->sectorsize)
-                        em = btrfs_get_extent_fiemap(inode, NULL, 0, 0,
-                                                     root->sectorsize, 0);
-                else
-                        em = btrfs_get_extent_fiemap(inode, NULL, 0,
-                                                     start - root->sectorsize,
-                                                     root->sectorsize, 0);
-                if (IS_ERR(em)) {
-                        ret = PTR_ERR(em);
-                        goto out;
-                }
-                last_end = em->start + em->len;
-                if (em->block_start == EXTENT_MAP_DELALLOC)
-                        last_end = min_t(u64, last_end, inode->i_size);
-                free_extent_map(em);
-        }
-        while (1) {
                em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0);
                if (IS_ERR(em)) {
                        ret = PTR_ERR(em);
+                        em = NULL;
                        break;
                }
-                if (em->block_start == EXTENT_MAP_HOLE) {
+                if (whence == SEEK_HOLE &&
-                        if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) {
+                    (em->block_start == EXTENT_MAP_HOLE ||
-                                if (last_end <= orig_start) {
+                     test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
-                                        free_extent_map(em);
+                        break;
-                                        ret = -ENXIO;
+                else if (whence == SEEK_DATA &&
-                                        break;
+                           (em->block_start != EXTENT_MAP_HOLE &&
-                                }
+                            !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
-                        }
+                        break;
-                        if (whence == SEEK_HOLE) {
-                                *offset = start;
-                                free_extent_map(em);
-                                break;
-                        }
-                } else {
-                        if (whence == SEEK_DATA) {
-                                if (em->block_start == EXTENT_MAP_DELALLOC) {
-                                        if (start >= inode->i_size) {
-                                                free_extent_map(em);
-                                                ret = -ENXIO;
-                                                break;
-                                        }
-                                }
-                                if (!test_bit(EXTENT_FLAG_PREALLOC,
-                                              &em->flags)) {
-                                        *offset = start;
-                                        free_extent_map(em);
-                                        break;
-                                }
-                        }
-                }
                start = em->start + em->len;
-                last_end = em->start + em->len;
-                if (em->block_start == EXTENT_MAP_DELALLOC)
-                        last_end = min_t(u64, last_end, inode->i_size);
-                if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) {
-                        free_extent_map(em);
-                        ret = -ENXIO;
-                        break;
-                }
                free_extent_map(em);
+                em = NULL;
                cond_resched();
        }
-        if (!ret)
+        free_extent_map(em);
-                *offset = min(*offset, inode->i_size);
+        if (!ret) {
-out:
+                if (whence == SEEK_DATA && start >= inode->i_size)
+                        ret = -ENXIO;
+                else
+                        *offset = min_t(loff_t, start, inode->i_size);
+        }
        unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
                             &cached_state, GFP_NOFS);
        return ret;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 3f0ddfce96e6..057be95b1e1e 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -218,7 +218,6 @@ int btrfs_check_trunc_cache_free_space(struct btrfs_root *root,
 int btrfs_truncate_free_space_cache(struct btrfs_root *root,
                                    struct btrfs_trans_handle *trans,
-                                    struct btrfs_path *path,
                                    struct inode *inode)
 {
        int ret = 0;
@@ -1009,8 +1008,13 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
        if (ret)
                goto out;
+        ret = btrfs_wait_ordered_range(inode, 0, (u64)-1);
-        btrfs_wait_ordered_range(inode, 0, (u64)-1);
+        if (ret) {
+                clear_extent_bit(&BTRFS_I(inode)->io_tree, 0, inode->i_size - 1,
+                                 EXTENT_DIRTY | EXTENT_DELALLOC, 0, 0, NULL,
+                                 GFP_NOFS);
+                goto out;
+        }
        key.objectid = BTRFS_FREE_SPACE_OBJECTID;
        key.offset = offset;
@@ -1431,13 +1435,19 @@ static void bitmap_set_bits(struct btrfs_free_space_ctl *ctl,
        ctl->free_space += bytes;
 }
+/*
+ * If we can not find suitable extent, we will use bytes to record
+ * the size of the max extent.
+ */
 static int search_bitmap(struct btrfs_free_space_ctl *ctl,
                         struct btrfs_free_space *bitmap_info, u64 *offset,
                         u64 *bytes)
 {
        unsigned long found_bits = 0;
+        unsigned long max_bits = 0;
        unsigned long bits, i;
        unsigned long next_zero;
+        unsigned long extent_bits;
        i = offset_to_bit(bitmap_info->offset, ctl->unit,
                          max_t(u64, *offset, bitmap_info->offset));
@@ -1446,9 +1456,12 @@ static int search_bitmap(struct btrfs_free_space_ctl *ctl,
        for_each_set_bit_from(i, bitmap_info->bitmap, BITS_PER_BITMAP) {
                next_zero = find_next_zero_bit(bitmap_info->bitmap,
                                               BITS_PER_BITMAP, i);
-                if ((next_zero - i) >= bits) {
+                extent_bits = next_zero - i;
-                        found_bits = next_zero - i;
+                if (extent_bits >= bits) {
+                        found_bits = extent_bits;
                        break;
+                } else if (extent_bits > max_bits) {
+                        max_bits = extent_bits;
                }
                i = next_zero;
        }
@@ -1459,38 +1472,41 @@ static int search_bitmap(struct btrfs_free_space_ctl *ctl,
                return 0;
        }
+        *bytes = (u64)(max_bits) * ctl->unit;
        return -1;
 }
+/* Cache the size of the max extent in bytes */
 static struct btrfs_free_space *
 find_free_space(struct btrfs_free_space_ctl *ctl, u64 *offset, u64 *bytes,
-                unsigned long align)
+                unsigned long align, u64 *max_extent_size)
 {
        struct btrfs_free_space *entry;
        struct rb_node *node;
-        u64 ctl_off;
        u64 tmp;
        u64 align_off;
        int ret;
        if (!ctl->free_space_offset.rb_node)
-                return NULL;
+                goto out;
        entry = tree_search_offset(ctl, offset_to_bitmap(ctl, *offset), 0, 1);
        if (!entry)
-                return NULL;
+                goto out;
        for (node = &entry->offset_index; node; node = rb_next(node)) {
                entry = rb_entry(node, struct btrfs_free_space, offset_index);
-                if (entry->bytes < *bytes)
+                if (entry->bytes < *bytes) {
+                        if (entry->bytes > *max_extent_size)
+                                *max_extent_size = entry->bytes;
                        continue;
+                }
                /* make sure the space returned is big enough
                 * to match our requested alignment
                 */
                if (*bytes >= align) {
-                        ctl_off = entry->offset - ctl->start;
+                        tmp = entry->offset - ctl->start + align - 1;
-                        tmp = ctl_off + align - 1;;
                        do_div(tmp, align);
                        tmp = tmp * align + ctl->start;
                        align_off = tmp - entry->offset;
@@ -1499,14 +1515,22 @@ find_free_space(struct btrfs_free_space_ctl *ctl, u64 *offset, u64 *bytes,
                        tmp = entry->offset;
                }
-                if (entry->bytes < *bytes + align_off)
+                if (entry->bytes < *bytes + align_off) {
+                        if (entry->bytes > *max_extent_size)
+                                *max_extent_size = entry->bytes;
                        continue;
+                }
                if (entry->bitmap) {
-                        ret = search_bitmap(ctl, entry, &tmp, bytes);
+                        u64 size = *bytes;
+                        ret = search_bitmap(ctl, entry, &tmp, &size);
                        if (!ret) {
                                *offset = tmp;
+                                *bytes = size;
                                return entry;
+                        } else if (size > *max_extent_size) {
+                                *max_extent_size = size;
                        }
                        continue;
                }
@@ -1515,7 +1539,7 @@ find_free_space(struct btrfs_free_space_ctl *ctl, u64 *offset, u64 *bytes,
                *bytes = entry->bytes - align_off;
                return entry;
        }
+out:
        return NULL;
 }
@@ -2116,7 +2140,8 @@ void btrfs_remove_free_space_cache(struct btrfs_block_group_cache *block_group)
 }
 u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
-                               u64 offset, u64 bytes, u64 empty_size)
+                               u64 offset, u64 bytes, u64 empty_size,
+                               u64 *max_extent_size)
 {
        struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
        struct btrfs_free_space *entry = NULL;
@@ -2127,7 +2152,7 @@ u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
        spin_lock(&ctl->tree_lock);
        entry = find_free_space(ctl, &offset, &bytes_search,
-                                block_group->full_stripe_len);
+                                block_group->full_stripe_len, max_extent_size);
        if (!entry)
                goto out;
@@ -2137,7 +2162,6 @@ u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
                if (!entry->bytes)
                        free_bitmap(ctl, entry);
        } else {
                unlink_free_space(ctl, entry);
                align_gap_len = offset - entry->offset;
                align_gap = entry->offset;
@@ -2151,7 +2175,6 @@ u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
                else
                        link_free_space(ctl, entry);
        }
 out:
        spin_unlock(&ctl->tree_lock);
@@ -2206,7 +2229,8 @@ int btrfs_return_cluster_to_free_space(
 static u64 btrfs_alloc_from_bitmap(struct btrfs_block_group_cache *block_group,
                                   struct btrfs_free_cluster *cluster,
                                   struct btrfs_free_space *entry,
-                                   u64 bytes, u64 min_start)
+                                   u64 bytes, u64 min_start,
+                                   u64 *max_extent_size)
 {
        struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
        int err;
@@ -2218,8 +2242,11 @@ static u64 btrfs_alloc_from_bitmap(struct btrfs_block_group_cache *block_group,
        search_bytes = bytes;
        err = search_bitmap(ctl, entry, &search_start, &search_bytes);
-        if (err)
+        if (err) {
+                if (search_bytes > *max_extent_size)
+                        *max_extent_size = search_bytes;
                return 0;
+        }
        ret = search_start;
        __bitmap_clear_bits(ctl, entry, ret, bytes);
@@ -2234,7 +2261,7 @@ static u64 btrfs_alloc_from_bitmap(struct btrfs_block_group_cache *block_group,
 */
 u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                             struct btrfs_free_cluster *cluster, u64 bytes,
-                             u64 min_start)
+                             u64 min_start, u64 *max_extent_size)
 {
        struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
        struct btrfs_free_space *entry = NULL;
@@ -2253,7 +2280,10 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                goto out;
        entry = rb_entry(node, struct btrfs_free_space, offset_index);
-        while(1) {
+        while (1) {
+                if (entry->bytes < bytes && entry->bytes > *max_extent_size)
+                        *max_extent_size = entry->bytes;
                if (entry->bytes < bytes ||
                    (!entry->bitmap && entry->offset < min_start)) {
                        node = rb_next(&entry->offset_index);
@@ -2267,7 +2297,8 @@ u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                if (entry->bitmap) {
                        ret = btrfs_alloc_from_bitmap(block_group,
                                                      cluster, entry, bytes,
-                                                      cluster->window_start);
+                                                      cluster->window_start,
+                                                      max_extent_size);
                        if (ret == 0) {
                                node = rb_next(&entry->offset_index);
                                if (!node)
@@ -2940,19 +2971,15 @@ out:
 int btrfs_write_out_ino_cache(struct btrfs_root *root,
                              struct btrfs_trans_handle *trans,
-                              struct btrfs_path *path)
+                              struct btrfs_path *path,
+                              struct inode *inode)
 {
        struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
-        struct inode *inode;
        int ret;
        if (!btrfs_test_opt(root, INODE_MAP_CACHE))
                return 0;
-        inode = lookup_free_ino_inode(root, path);
-        if (IS_ERR(inode))
-                return 0;
        ret = __btrfs_write_out_cache(root, inode, ctl, NULL, trans, path, 0);
        if (ret) {
                btrfs_delalloc_release_metadata(inode, inode->i_size);
@@ -2963,7 +2990,6 @@ int btrfs_write_out_ino_cache(struct btrfs_root *root,
 #endif
        }
-        iput(inode);
        return ret;
 }
diff --git a/fs/btrfs/free-space-cache.h b/fs/btrfs/free-space-cache.h
index c74904167476..0cf4977ef70d 100644
--- a/fs/btrfs/free-space-cache.h
+++ b/fs/btrfs/free-space-cache.h
@@ -58,7 +58,6 @@ int btrfs_check_trunc_cache_free_space(struct btrfs_root *root,
                                       struct btrfs_block_rsv *rsv);
 int btrfs_truncate_free_space_cache(struct btrfs_root *root,
                                    struct btrfs_trans_handle *trans,
-                                    struct btrfs_path *path,
                                    struct inode *inode);
 int load_free_space_cache(struct btrfs_fs_info *fs_info,
                          struct btrfs_block_group_cache *block_group);
@@ -76,7 +75,8 @@ int load_free_ino_cache(struct btrfs_fs_info *fs_info,
                        struct btrfs_root *root);
 int btrfs_write_out_ino_cache(struct btrfs_root *root,
                              struct btrfs_trans_handle *trans,
-                              struct btrfs_path *path);
+                              struct btrfs_path *path,
+                              struct inode *inode);
 void btrfs_init_free_space_ctl(struct btrfs_block_group_cache *block_group);
 int __btrfs_add_free_space(struct btrfs_free_space_ctl *ctl,
@@ -94,7 +94,8 @@ void __btrfs_remove_free_space_cache(struct btrfs_free_space_ctl *ctl);
 void btrfs_remove_free_space_cache(struct btrfs_block_group_cache
                                     *block_group);
 u64 btrfs_find_space_for_alloc(struct btrfs_block_group_cache *block_group,
-                               u64 offset, u64 bytes, u64 empty_size);
+                               u64 offset, u64 bytes, u64 empty_size,
+                               u64 *max_extent_size);
 u64 btrfs_find_ino_for_alloc(struct btrfs_root *fs_root);
 void btrfs_dump_free_space(struct btrfs_block_group_cache *block_group,
                           u64 bytes);
@@ -105,7 +106,7 @@ int btrfs_find_space_cluster(struct btrfs_root *root,
 void btrfs_init_free_cluster(struct btrfs_free_cluster *cluster);
 u64 btrfs_alloc_from_cluster(struct btrfs_block_group_cache *block_group,
                             struct btrfs_free_cluster *cluster, u64 bytes,
-                             u64 min_start);
+                             u64 min_start, u64 *max_extent_size);
 int btrfs_return_cluster_to_free_space(
                               struct btrfs_block_group_cache *block_group,
                               struct btrfs_free_cluster *cluster);
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index e0b7034d6343..ec82fae07097 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -369,7 +369,7 @@ static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
                goto out;
        leaf = path->nodes[0];
-        item = btrfs_item_nr(leaf, path->slots[0]);
+        item = btrfs_item_nr(path->slots[0]);
        ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
        ptr += btrfs_item_size(leaf, item) - ins_len;
        extref = (struct btrfs_inode_extref *)ptr;
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index 2c66ddbbe670..ab485e57b6fe 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -78,10 +78,8 @@ again:
                            btrfs_transaction_in_commit(fs_info)) {
                                leaf = path->nodes[0];
-                                if (btrfs_header_nritems(leaf) == 0) {
+                                if (WARN_ON(btrfs_header_nritems(leaf) == 0))
-                                        WARN_ON(1);
                                        break;
-                                }
                                /*
                                 * Save the key so we can advances forward
@@ -237,7 +235,7 @@ again:
                start_caching(root);
                if (objectid <= root->cache_progress ||
-                    objectid > root->highest_objectid)
+                    objectid >= root->highest_objectid)
                        __btrfs_add_free_space(ctl, objectid, 1);
                else
                        __btrfs_add_free_space(pinned, objectid, 1);
@@ -412,8 +410,7 @@ int btrfs_save_ino_cache(struct btrfs_root *root,
                return 0;
        /* Don't save inode cache if we are deleting this root */
-        if (btrfs_root_refs(&root->root_item) == 0 &&
+        if (btrfs_root_refs(&root->root_item) == 0)
-            root != root->fs_info->tree_root)
                return 0;
        if (!btrfs_test_opt(root, INODE_MAP_CACHE))
@@ -467,7 +464,7 @@ again:
        }
        if (i_size_read(inode) > 0) {
-                ret = btrfs_truncate_free_space_cache(root, trans, path, inode);
+                ret = btrfs_truncate_free_space_cache(root, trans, inode);
                if (ret) {
                        if (ret != -ENOSPC)
                                btrfs_abort_transaction(trans, root, ret);
@@ -504,7 +501,7 @@ again:
        }
        btrfs_free_reserved_data_space(inode, prealloc);
-        ret = btrfs_write_out_ino_cache(root, trans, path);
+        ret = btrfs_write_out_ino_cache(root, trans, path, inode);
 out_put:
        iput(inode);
 out_release:
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index f338c5672d58..f1a77449d032 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -43,7 +43,6 @@
 #include <linux/btrfs.h>
 #include <linux/blkdev.h>
 #include <linux/posix_acl_xattr.h>
-#include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -844,7 +843,10 @@ static noinline int cow_file_range(struct inode *inode,
        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
        int ret = 0;
-        BUG_ON(btrfs_is_free_space_inode(inode));
+        if (btrfs_is_free_space_inode(inode)) {
+                WARN_ON_ONCE(1);
+                return -EINVAL;
+        }
        num_bytes = ALIGN(end - start + 1, blocksize);
        num_bytes = max(blocksize,  num_bytes);
@@ -1178,10 +1180,8 @@ static noinline int run_delalloc_nocow(struct inode *inode,
        while (1) {
                ret = btrfs_lookup_file_extent(trans, root, path, ino,
                                               cur_offset, 0);
-                if (ret < 0) {
+                if (ret < 0)
-                        btrfs_abort_transaction(trans, root, ret);
                        goto error;
-                }
                if (ret > 0 && path->slots[0] > 0 && check_prev) {
                        leaf = path->nodes[0];
                        btrfs_item_key_to_cpu(leaf, &found_key,
@@ -1195,10 +1195,8 @@ next_slot:
                leaf = path->nodes[0];
                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
                        ret = btrfs_next_leaf(root, path);
-                        if (ret < 0) {
+                        if (ret < 0)
-                                btrfs_abort_transaction(trans, root, ret);
                                goto error;
-                        }
                        if (ret > 0)
                                break;
                        leaf = path->nodes[0];
@@ -1289,10 +1287,8 @@ out_check:
                        ret = cow_file_range(inode, locked_page,
                                             cow_start, found_key.offset - 1,
                                             page_started, nr_written, 1);
-                        if (ret) {
+                        if (ret)
-                                btrfs_abort_transaction(trans, root, ret);
                                goto error;
-                        }
                        cow_start = (u64)-1;
                }
@@ -1339,10 +1335,8 @@ out_check:
                    BTRFS_DATA_RELOC_TREE_OBJECTID) {
                        ret = btrfs_reloc_clone_csums(inode, cur_offset,
                                                      num_bytes);
-                        if (ret) {
+                        if (ret)
-                                btrfs_abort_transaction(trans, root, ret);
                                goto error;
-                        }
                }
                extent_clear_unlock_delalloc(inode, cur_offset,
@@ -1364,10 +1358,8 @@ out_check:
        if (cow_start != (u64)-1) {
                ret = cow_file_range(inode, locked_page, cow_start, end,
                                     page_started, nr_written, 1);
-                if (ret) {
+                if (ret)
-                        btrfs_abort_transaction(trans, root, ret);
                        goto error;
-                }
        }
 error:
@@ -1551,7 +1543,13 @@ static void btrfs_clear_bit_hook(struct inode *inode,
                        spin_unlock(&BTRFS_I(inode)->lock);
                }
-                if (*bits & EXTENT_DO_ACCOUNTING)
+                /*
+                 * We don't reserve metadata space for space cache inodes so we
+                 * don't need to call dellalloc_release_metadata if there is an
+                 * error.
+                 */
+                if (*bits & EXTENT_DO_ACCOUNTING &&
+                    root != root->fs_info->tree_root)
                        btrfs_delalloc_release_metadata(inode, len);
                if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
@@ -2041,10 +2039,8 @@ static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
                key.offset = offset;
        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
-        if (ret < 0) {
+        if (WARN_ON(ret < 0))
-                WARN_ON(1);
                return ret;
-        }
        ret = 0;
        while (1) {
@@ -2133,7 +2129,8 @@ static noinline bool record_extent_backrefs(struct btrfs_path *path,
                                                  old->extent_offset, fs_info,
                                                  path, record_one_backref,
                                                  old);
-                BUG_ON(ret < 0 && ret != -ENOENT);
+                if (ret < 0 && ret != -ENOENT)
+                        return false;
                /* no backref to be processed for this extent */
                if (!old->count) {
@@ -2367,10 +2364,23 @@ out_unlock:
        return ret;
 }
+static void free_sa_defrag_extent(struct new_sa_defrag_extent *new)
+{
+        struct old_sa_defrag_extent *old, *tmp;
+        if (!new)
+                return;
+        list_for_each_entry_safe(old, tmp, &new->head, list) {
+                list_del(&old->list);
+                kfree(old);
+        }
+        kfree(new);
+}
 static void relink_file_extents(struct new_sa_defrag_extent *new)
 {
        struct btrfs_path *path;
-        struct old_sa_defrag_extent *old, *tmp;
        struct sa_defrag_extent_backref *backref;
        struct sa_defrag_extent_backref *prev = NULL;
        struct inode *inode;
@@ -2413,16 +2423,11 @@ static void relink_file_extents(struct new_sa_defrag_extent *new)
        kfree(prev);
        btrfs_free_path(path);
-        list_for_each_entry_safe(old, tmp, &new->head, list) {
-                list_del(&old->list);
-                kfree(old);
-        }
 out:
+        free_sa_defrag_extent(new);
        atomic_dec(&root->fs_info->defrag_running);
        wake_up(&root->fs_info->transaction_wait);
-        kfree(new);
 }
 static struct new_sa_defrag_extent *
@@ -2432,7 +2437,7 @@ record_old_file_extents(struct inode *inode,
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_path *path;
        struct btrfs_key key;
-        struct old_sa_defrag_extent *old, *tmp;
+        struct old_sa_defrag_extent *old;
        struct new_sa_defrag_extent *new;
        int ret;
@@ -2480,7 +2485,7 @@ record_old_file_extents(struct inode *inode,
                if (slot >= btrfs_header_nritems(l)) {
                        ret = btrfs_next_leaf(root, path);
                        if (ret < 0)
-                                goto out_free_list;
+                                goto out_free_path;
                        else if (ret > 0)
                                break;
                        continue;
@@ -2509,7 +2514,7 @@ record_old_file_extents(struct inode *inode,
                old = kmalloc(sizeof(*old), GFP_NOFS);
                if (!old)
-                        goto out_free_list;
+                        goto out_free_path;
                offset = max(new->file_pos, key.offset);
                end = min(new->file_pos + new->len, key.offset + num_bytes);
@@ -2531,15 +2536,10 @@ next:
        return new;
-out_free_list:
-        list_for_each_entry_safe(old, tmp, &new->head, list) {
-                list_del(&old->list);
-                kfree(old);
-        }
 out_free_path:
        btrfs_free_path(path);
 out_kfree:
-        kfree(new);
+        free_sa_defrag_extent(new);
        return NULL;
 }
@@ -2710,8 +2710,14 @@ out:
        btrfs_remove_ordered_extent(inode, ordered_extent);
        /* for snapshot-aware defrag */
-        if (new)
+        if (new) {
-                relink_file_extents(new);
+                if (ret) {
+                        free_sa_defrag_extent(new);
+                        atomic_dec(&root->fs_info->defrag_running);
+                } else {
+                        relink_file_extents(new);
+                }
+        }
        /* once for us */
        btrfs_put_ordered_extent(ordered_extent);
@@ -2969,6 +2975,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
        if (insert >= 1) {
                ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
                if (ret) {
+                        atomic_dec(&root->orphan_inodes);
                        if (reserve) {
                                clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
                                          &BTRFS_I(inode)->runtime_flags);
@@ -3018,14 +3025,16 @@ static int btrfs_orphan_del(struct btrfs_trans_handle *trans,
                release_rsv = 1;
        spin_unlock(&root->orphan_lock);
-        if (trans && delete_item)
+        if (delete_item) {
-                ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
-        if (release_rsv) {
-                btrfs_orphan_release_metadata(inode);
                atomic_dec(&root->orphan_inodes);
+                if (trans)
+                        ret = btrfs_del_orphan_item(trans, root,
+                                                    btrfs_ino(inode));
        }
+        if (release_rsv)
+                btrfs_orphan_release_metadata(inode);
        return ret;
 }
@@ -3172,8 +3181,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                /* if we have links, this was a truncate, lets do that */
                if (inode->i_nlink) {
-                        if (!S_ISREG(inode->i_mode)) {
+                        if (WARN_ON(!S_ISREG(inode->i_mode))) {
-                                WARN_ON(1);
                                iput(inode);
                                continue;
                        }
@@ -3636,7 +3644,7 @@ int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
        int ret;
        ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
        if (!ret) {
-                btrfs_drop_nlink(inode);
+                drop_nlink(inode);
                ret = btrfs_update_inode(trans, root, inode);
        }
        return ret;
@@ -4230,15 +4238,16 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
        while (1) {
                struct btrfs_ordered_extent *ordered;
-                btrfs_wait_ordered_range(inode, hole_start,
-                                         block_end - hole_start);
                lock_extent_bits(io_tree, hole_start, block_end - 1, 0,
                                 &cached_state);
-                ordered = btrfs_lookup_ordered_extent(inode, hole_start);
+                ordered = btrfs_lookup_ordered_range(inode, hole_start,
+                                                     block_end - hole_start);
                if (!ordered)
                        break;
                unlock_extent_cached(io_tree, hole_start, block_end - 1,
                                     &cached_state, GFP_NOFS);
+                btrfs_start_ordered_extent(inode, ordered, 1);
                btrfs_put_ordered_extent(ordered);
        }
@@ -4472,8 +4481,10 @@ void btrfs_evict_inode(struct inode *inode)
        trace_btrfs_inode_evict(inode);
        truncate_inode_pages(&inode->i_data, 0);
-        if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
+        if (inode->i_nlink &&
-                               btrfs_is_free_space_inode(inode)))
+            ((btrfs_root_refs(&root->root_item) != 0 &&
+              root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID) ||
+             btrfs_is_free_space_inode(inode)))
                goto no_delete;
        if (is_bad_inode(inode)) {
@@ -4490,7 +4501,8 @@ void btrfs_evict_inode(struct inode *inode)
        }
        if (inode->i_nlink > 0) {
-                BUG_ON(btrfs_root_refs(&root->root_item) != 0);
+                BUG_ON(btrfs_root_refs(&root->root_item) != 0 &&
+                       root->root_key.objectid != BTRFS_ROOT_TREE_OBJECTID);
                goto no_delete;
        }
@@ -4688,11 +4700,11 @@ static void inode_tree_add(struct inode *inode)
        struct btrfs_inode *entry;
        struct rb_node **p;
        struct rb_node *parent;
+        struct rb_node *new = &BTRFS_I(inode)->rb_node;
        u64 ino = btrfs_ino(inode);
        if (inode_unhashed(inode))
                return;
-again:
        parent = NULL;
        spin_lock(&root->inode_lock);
        p = &root->inode_tree.rb_node;
@@ -4707,14 +4719,14 @@ again:
                else {
                        WARN_ON(!(entry->vfs_inode.i_state &
                                  (I_WILL_FREE | I_FREEING)));
-                        rb_erase(parent, &root->inode_tree);
+                        rb_replace_node(parent, new, &root->inode_tree);
                        RB_CLEAR_NODE(parent);
                        spin_unlock(&root->inode_lock);
-                        goto again;
+                        return;
                }
        }
-        rb_link_node(&BTRFS_I(inode)->rb_node, parent, p);
+        rb_link_node(new, parent, p);
-        rb_insert_color(&BTRFS_I(inode)->rb_node, &root->inode_tree);
+        rb_insert_color(new, &root->inode_tree);
        spin_unlock(&root->inode_lock);
 }
@@ -4731,14 +4743,7 @@ static void inode_tree_del(struct inode *inode)
        }
        spin_unlock(&root->inode_lock);
-        /*
+        if (empty && btrfs_root_refs(&root->root_item) == 0) {
-         * Free space cache has inodes in the tree root, but the tree root has a
-         * root_refs of 0, so this could end up dropping the tree root as a
-         * snapshot, so we need the extra !root->fs_info->tree_root check to
-         * make sure we don't drop it.
-         */
-        if (empty && btrfs_root_refs(&root->root_item) == 0 &&
-            root != root->fs_info->tree_root) {
                synchronize_srcu(&root->fs_info->subvol_srcu);
                spin_lock(&root->inode_lock);
                empty = RB_EMPTY_ROOT(&root->inode_tree);
@@ -4831,10 +4836,12 @@ static struct inode *btrfs_iget_locked(struct super_block *s,
 {
        struct inode *inode;
        struct btrfs_iget_args args;
+        unsigned long hashval = btrfs_inode_hash(objectid, root);
        args.ino = objectid;
        args.root = root;
-        inode = iget5_locked(s, objectid, btrfs_find_actor,
+        inode = iget5_locked(s, hashval, btrfs_find_actor,
                             btrfs_init_locked_inode,
                             (void *)&args);
        return inode;
@@ -5048,7 +5055,7 @@ static int btrfs_real_readdir(struct file *file, struct dir_context *ctx)
                        continue;
                }
-                item = btrfs_item_nr(leaf, slot);
+                item = btrfs_item_nr(slot);
                btrfs_item_key_to_cpu(leaf, &found_key, slot);
                if (found_key.objectid != key.objectid)
@@ -5454,7 +5461,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
                                BTRFS_INODE_NODATASUM;
        }
-        insert_inode_hash(inode);
+        btrfs_insert_inode_hash(inode);
        inode_tree_add(inode);
        trace_btrfs_inode_new(inode);
@@ -5730,7 +5737,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
                goto fail;
        }
-        btrfs_inc_nlink(inode);
+        inc_nlink(inode);
        inode_inc_iversion(inode);
        inode->i_ctime = CURRENT_TIME;
        ihold(inode);
@@ -5860,7 +5867,7 @@ static noinline int uncompress_inline(struct btrfs_path *path,
        compress_type = btrfs_file_extent_compression(leaf, item);
        max_size = btrfs_file_extent_ram_bytes(leaf, item);
        inline_size = btrfs_file_extent_inline_item_len(leaf,
-                                        btrfs_item_nr(leaf, path->slots[0]));
+                                        btrfs_item_nr(path->slots[0]));
        tmp = kmalloc(inline_size, GFP_NOFS);
        if (!tmp)
                return -ENOMEM;
@@ -5974,7 +5981,14 @@ again:
        found_type = btrfs_key_type(&found_key);
        if (found_key.objectid != objectid ||
            found_type != BTRFS_EXTENT_DATA_KEY) {
-                goto not_found;
+                /*
+                 * If we backup past the first extent we want to move forward
+                 * and see if there is an extent in front of us, otherwise we'll
+                 * say there is a hole for our whole search range which can
+                 * cause problems.
+                 */
+                extent_end = start;
+                goto next;
        }
        found_type = btrfs_file_extent_type(leaf, item);
@@ -5989,7 +6003,7 @@ again:
                size = btrfs_file_extent_inline_len(leaf, item);
                extent_end = ALIGN(extent_start + size, root->sectorsize);
        }
+next:
        if (start >= extent_end) {
                path->slots[0]++;
                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
@@ -6173,8 +6187,7 @@ insert:
        write_unlock(&em_tree->lock);
 out:
-        if (em)
+        trace_btrfs_get_extent(root, em);
-                trace_btrfs_get_extent(root, em);
        if (path)
                btrfs_free_path(path);
@@ -6249,7 +6262,7 @@ struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *pag
        /* adjust the range_start to make sure it doesn't
         * go backwards from the start they passed in
         */
-        range_start = max(start,range_start);
+        range_start = max(start, range_start);
        found = found_end - range_start;
        if (found > 0) {
@@ -6437,6 +6450,7 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
        if (btrfs_extent_readonly(root, disk_bytenr))
                goto out;
+        btrfs_release_path(path);
        /*
         * look for other files referencing this extent, if we
@@ -7052,7 +7066,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                        }
                } else {
                        submit_len += bvec->bv_len;
-                        nr_pages ++;
+                        nr_pages++;
                        bvec++;
                }
        }
@@ -7221,7 +7235,9 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
         * outstanding dirty pages are on disk.
         */
        count = iov_length(iov, nr_segs);
-        btrfs_wait_ordered_range(inode, offset, count);
+        ret = btrfs_wait_ordered_range(inode, offset, count);
+        if (ret)
+                return ret;
        if (rw & WRITE) {
                /*
@@ -7562,7 +7578,10 @@ static int btrfs_truncate(struct inode *inode)
        u64 mask = root->sectorsize - 1;
        u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
-        btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
+        ret = btrfs_wait_ordered_range(inode, inode->i_size & (~mask),
+                                       (u64)-1);
+        if (ret)
+                return ret;
        /*
         * Yes ladies and gentelment, this is indeed ugly.  The fact is we have
@@ -7786,6 +7805,14 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
        return inode;
 }
+#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
+void btrfs_test_destroy_inode(struct inode *inode)
+{
+        btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
+        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
+}
+#endif
 static void btrfs_i_callback(struct rcu_head *head)
 {
        struct inode *inode = container_of(head, struct inode, i_rcu);
@@ -7856,8 +7883,7 @@ int btrfs_drop_inode(struct inode *inode)
                return 1;
        /* the snap/subvol tree is on deleting */
-        if (btrfs_root_refs(&root->root_item) == 0 &&
+        if (btrfs_root_refs(&root->root_item) == 0)
-            root != root->fs_info->tree_root)
                return 1;
        else
                return generic_drop_inode(inode);
@@ -7986,7 +8012,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        /* check for collisions, even if the  name isn't there */
-        ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
+        ret = btrfs_check_dir_item_collision(dest, new_dir->i_ino,
                             new_dentry->d_name.name,
                             new_dentry->d_name.len);
@@ -7994,8 +8020,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                if (ret == -EEXIST) {
                        /* we shouldn't get
                         * eexist without a new_inode */
-                        if (!new_inode) {
+                        if (WARN_ON(!new_inode)) {
-                                WARN_ON(1);
                                return ret;
                        }
                } else {
@@ -8143,18 +8168,24 @@ out_notrans:
 static void btrfs_run_delalloc_work(struct btrfs_work *work)
 {
        struct btrfs_delalloc_work *delalloc_work;
+        struct inode *inode;
        delalloc_work = container_of(work, struct btrfs_delalloc_work,
                                     work);
-        if (delalloc_work->wait)
+        inode = delalloc_work->inode;
-                btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
+        if (delalloc_work->wait) {
-        else
+                btrfs_wait_ordered_range(inode, 0, (u64)-1);
-                filemap_flush(delalloc_work->inode->i_mapping);
+        } else {
+                filemap_flush(inode->i_mapping);
+                if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
+                             &BTRFS_I(inode)->runtime_flags))
+                        filemap_flush(inode->i_mapping);
+        }
        if (delalloc_work->delay_iput)
-                btrfs_add_delayed_iput(delalloc_work->inode);
+                btrfs_add_delayed_iput(inode);
        else
-                iput(delalloc_work->inode);
+                iput(inode);
        complete(&delalloc_work->completion);
 }
@@ -8216,6 +8247,10 @@ static int __start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
                work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
                if (unlikely(!work)) {
+                        if (delay_iput)
+                                btrfs_add_delayed_iput(inode);
+                        else
+                                iput(inode);
                        ret = -ENOMEM;
                        goto out;
                }
@@ -8271,8 +8306,7 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
        return ret;
 }
-int btrfs_start_all_delalloc_inodes(struct btrfs_fs_info *fs_info,
+int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int delay_iput)
-                                    int delay_iput)
 {
        struct btrfs_root *root;
        struct list_head splice;
@@ -8332,14 +8366,14 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
        int err;
        int drop_inode = 0;
        u64 objectid;
-        u64 index = 0 ;
+        u64 index = 0;
        int name_len;
        int datasize;
        unsigned long ptr;
        struct btrfs_file_extent_item *ei;
        struct extent_buffer *leaf;
-        name_len = strlen(symname) + 1;
+        name_len = strlen(symname);
        if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
                return -ENAMETOOLONG;
@@ -8427,7 +8461,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
        inode->i_mapping->a_ops = &btrfs_symlink_aops;
        inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
        inode_set_bytes(inode, name_len);
-        btrfs_i_size_write(inode, name_len - 1);
+        btrfs_i_size_write(inode, name_len);
        err = btrfs_update_inode(trans, root, inode);
        if (err)
                drop_inode = 1;
@@ -8486,6 +8520,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                                  ins.offset, 0, 0, 0,
                                                  BTRFS_FILE_EXTENT_PREALLOC);
                if (ret) {
+                        btrfs_free_reserved_extent(root, ins.objectid,
+                                                   ins.offset);
                        btrfs_abort_transaction(trans, root, ret);
                        if (own_trans)
                                btrfs_end_transaction(trans, root);
@@ -8613,11 +8649,13 @@ static const struct inode_operations btrfs_dir_inode_operations = {
        .removexattr    = btrfs_removexattr,
        .permission     = btrfs_permission,
        .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct inode_operations btrfs_dir_ro_inode_operations = {
        .lookup         = btrfs_lookup,
        .permission     = btrfs_permission,
        .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct file_operations btrfs_dir_file_operations = {
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 1a5b9462dd9a..a111622598b0 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -44,7 +44,6 @@
 #include <linux/uuid.h>
 #include <linux/btrfs.h>
 #include <linux/uaccess.h>
-#include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
 #include "transaction.h"
@@ -321,7 +320,7 @@ static int btrfs_ioctl_getversion(struct file *file, int __user *arg)
 static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
 {
-        struct btrfs_fs_info *fs_info = btrfs_sb(fdentry(file)->d_sb);
+        struct btrfs_fs_info *fs_info = btrfs_sb(file_inode(file)->i_sb);
        struct btrfs_device *device;
        struct request_queue *q;
        struct fstrim_range range;
@@ -369,9 +368,13 @@ static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
 int btrfs_is_empty_uuid(u8 *uuid)
 {
-        static char empty_uuid[BTRFS_UUID_SIZE] = {0};
+        int i;
-        return !memcmp(uuid, empty_uuid, BTRFS_UUID_SIZE);
+        for (i = 0; i < BTRFS_UUID_SIZE; i++) {
+                if (uuid[i])
+                        return 0;
+        }
+        return 1;
 }
 static noinline int create_subvol(struct inode *dir,
@@ -436,7 +439,7 @@ static noinline int create_subvol(struct inode *dir,
        btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
        btrfs_set_header_owner(leaf, objectid);
-        write_extent_buffer(leaf, root->fs_info->fsid, btrfs_header_fsid(leaf),
+        write_extent_buffer(leaf, root->fs_info->fsid, btrfs_header_fsid(),
                            BTRFS_FSID_SIZE);
        write_extent_buffer(leaf, root->fs_info->chunk_tree_uuid,
                            btrfs_header_chunk_tree_uuid(leaf),
@@ -574,7 +577,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
        if (ret)
                return ret;
-        btrfs_wait_ordered_extents(root, 0);
+        btrfs_wait_ordered_extents(root, -1);
        pending_snapshot = kzalloc(sizeof(*pending_snapshot), GFP_NOFS);
        if (!pending_snapshot)
@@ -688,7 +691,7 @@ static inline int btrfs_check_sticky(struct inode *dir, struct inode *inode)
 *     nfs_async_unlink().
 */
-static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir)
+static int btrfs_may_delete(struct inode *dir, struct dentry *victim, int isdir)
 {
        int error;
@@ -842,7 +845,6 @@ static int find_new_extents(struct btrfs_root *root,
 {
        struct btrfs_path *path;
        struct btrfs_key min_key;
-        struct btrfs_key max_key;
        struct extent_buffer *leaf;
        struct btrfs_file_extent_item *extent;
        int type;
@@ -857,15 +859,10 @@ static int find_new_extents(struct btrfs_root *root,
        min_key.type = BTRFS_EXTENT_DATA_KEY;
        min_key.offset = *off;
-        max_key.objectid = ino;
-        max_key.type = (u8)-1;
-        max_key.offset = (u64)-1;
        path->keep_locks = 1;
-        while(1) {
+        while (1) {
-                ret = btrfs_search_forward(root, &min_key, &max_key,
+                ret = btrfs_search_forward(root, &min_key, path, newer_than);
-                                           path, newer_than);
                if (ret != 0)
                        goto none;
                if (min_key.objectid != ino)
@@ -1206,7 +1203,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                ra = &file->f_ra;
        }
-        pages = kmalloc(sizeof(struct page *) * max_cluster,
+        pages = kmalloc_array(max_cluster, sizeof(struct page *),
                        GFP_NOFS);
        if (!pages) {
                ret = -ENOMEM;
@@ -1893,7 +1890,6 @@ static noinline int search_ioctl(struct inode *inode,
 {
        struct btrfs_root *root;
        struct btrfs_key key;
-        struct btrfs_key max_key;
        struct btrfs_path *path;
        struct btrfs_ioctl_search_key *sk = &args->key;
        struct btrfs_fs_info *info = BTRFS_I(inode)->root->fs_info;
@@ -1925,15 +1921,10 @@ static noinline int search_ioctl(struct inode *inode,
        key.type = sk->min_type;
        key.offset = sk->min_offset;
-        max_key.objectid = sk->max_objectid;
-        max_key.type = sk->max_type;
-        max_key.offset = sk->max_offset;
        path->keep_locks = 1;
-        while(1) {
+        while (1) {
-                ret = btrfs_search_forward(root, &key, &max_key, path,
+                ret = btrfs_search_forward(root, &key, path, sk->min_transid);
-                                           sk->min_transid);
                if (ret != 0) {
                        if (ret > 0)
                                ret = 0;
@@ -2018,7 +2009,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
        key.type = BTRFS_INODE_REF_KEY;
        key.offset = (u64)-1;
-        while(1) {
+        while (1) {
                ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                if (ret < 0)
                        goto out;
@@ -2047,7 +2038,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
                }
                *(ptr + len) = '/';
-                read_extent_buffer(l, ptr,(unsigned long)(iref + 1), len);
+                read_extent_buffer(l, ptr, (unsigned long)(iref + 1), len);
                if (key.offset == BTRFS_FIRST_FREE_OBJECTID)
                        break;
@@ -2058,7 +2049,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
                dirid = key.objectid;
        }
        memmove(name, ptr, total_len);
-        name[total_len]='\0';
+        name[total_len] = '\0';
        ret = 0;
 out:
        btrfs_free_path(path);
@@ -2098,7 +2089,7 @@ static noinline int btrfs_ioctl_ino_lookup(struct file *file,
 static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                                             void __user *arg)
 {
-        struct dentry *parent = fdentry(file);
+        struct dentry *parent = file->f_path.dentry;
        struct dentry *dentry;
        struct inode *dir = parent->d_inode;
        struct inode *inode;
@@ -2144,7 +2135,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
        inode = dentry->d_inode;
        dest = BTRFS_I(inode)->root;
-        if (!capable(CAP_SYS_ADMIN)){
+        if (!capable(CAP_SYS_ADMIN)) {
                /*
                 * Regular user.  Only allow this with a special mount
                 * option, when the user has write+exec access to the
@@ -2696,9 +2687,9 @@ out_unlock:
 static long btrfs_ioctl_file_extent_same(struct file *file,
                                         void __user *argp)
 {
-        struct btrfs_ioctl_same_args *args = argp;
+        struct btrfs_ioctl_same_args tmp;
-        struct btrfs_ioctl_same_args same;
+        struct btrfs_ioctl_same_args *same;
-        struct btrfs_ioctl_same_extent_info info;
+        struct btrfs_ioctl_same_extent_info *info;
        struct inode *src = file->f_dentry->d_inode;
        struct file *dst_file = NULL;
        struct inode *dst;
@@ -2706,6 +2697,7 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
        u64 len;
        int i;
        int ret;
+        unsigned long size;
        u64 bs = BTRFS_I(src)->root->fs_info->sb->s_blocksize;
        bool is_admin = capable(CAP_SYS_ADMIN);
@@ -2716,15 +2708,25 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
        if (ret)
                return ret;
-        if (copy_from_user(&same,
+        if (copy_from_user(&tmp,
                           (struct btrfs_ioctl_same_args __user *)argp,
-                           sizeof(same))) {
+                           sizeof(tmp))) {
                ret = -EFAULT;
                goto out;
        }
-        off = same.logical_offset;
+        size = sizeof(tmp) +
-        len = same.length;
+                tmp.dest_count * sizeof(struct btrfs_ioctl_same_extent_info);
+        same = memdup_user((struct btrfs_ioctl_same_args __user *)argp, size);
+        if (IS_ERR(same)) {
+                ret = PTR_ERR(same);
+                goto out;
+        }
+        off = same->logical_offset;
+        len = same->length;
        /*
         * Limit the total length we will dedupe for each operation.
@@ -2752,27 +2754,28 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
        if (!S_ISREG(src->i_mode))
                goto out;
-        ret = 0;
+        /* pre-format output fields to sane values */
-        for (i = 0; i < same.dest_count; i++) {
+        for (i = 0; i < same->dest_count; i++) {
-                if (copy_from_user(&info, &args->info[i], sizeof(info))) {
+                same->info[i].bytes_deduped = 0ULL;
-                        ret = -EFAULT;
+                same->info[i].status = 0;
-                        goto out;
+        }
-                }
-                info.bytes_deduped = 0;
+        ret = 0;
+        for (i = 0; i < same->dest_count; i++) {
+                info = &same->info[i];
-                dst_file = fget(info.fd);
+                dst_file = fget(info->fd);
                if (!dst_file) {
-                        info.status = -EBADF;
+                        info->status = -EBADF;
                        goto next;
                }
                if (!(is_admin || (dst_file->f_mode & FMODE_WRITE))) {
-                        info.status = -EINVAL;
+                        info->status = -EINVAL;
                        goto next;
                }
-                info.status = -EXDEV;
+                info->status = -EXDEV;
                if (file->f_path.mnt != dst_file->f_path.mnt)
                        goto next;
@@ -2781,32 +2784,29 @@ static long btrfs_ioctl_file_extent_same(struct file *file,
                        goto next;
                if (S_ISDIR(dst->i_mode)) {
-                        info.status = -EISDIR;
+                        info->status = -EISDIR;
                        goto next;
                }
                if (!S_ISREG(dst->i_mode)) {
-                        info.status = -EACCES;
+                        info->status = -EACCES;
                        goto next;
                }
-                info.status = btrfs_extent_same(src, off, len, dst,
+                info->status = btrfs_extent_same(src, off, len, dst,
-                                                info.logical_offset);
+                                                info->logical_offset);
-                if (info.status == 0)
+                if (info->status == 0)
-                        info.bytes_deduped += len;
+                        info->bytes_deduped += len;
 next:
                if (dst_file)
                        fput(dst_file);
-                if (__put_user_unaligned(info.status, &args->info[i].status) ||
-                    __put_user_unaligned(info.bytes_deduped,
-                                         &args->info[i].bytes_deduped)) {
-                        ret = -EFAULT;
-                        goto out;
-                }                                                               
        }
+        ret = copy_to_user(argp, same, size);
+        if (ret)
+                ret = -EFAULT;
 out:
        mnt_drop_write_file(file);
        return ret;
@@ -3105,7 +3105,7 @@ out:
 static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                       u64 off, u64 olen, u64 destoff)
 {
-        struct inode *inode = fdentry(file)->d_inode;
+        struct inode *inode = file_inode(file);
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct fd src_file;
        struct inode *src;
@@ -3310,7 +3310,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
        }
        if (!objectid)
-                objectid = root->root_key.objectid;
+                objectid = BTRFS_FS_TREE_OBJECTID;
        location.objectid = objectid;
        location.type = BTRFS_ROOT_ITEM_KEY;
@@ -3665,9 +3665,10 @@ static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
        switch (p->cmd) {
        case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
-                if (root->fs_info->sb->s_flags & MS_RDONLY)
+                if (root->fs_info->sb->s_flags & MS_RDONLY) {
-                        return -EROFS;
+                        ret = -EROFS;
+                        goto out;
+                }
                if (atomic_xchg(
                        &root->fs_info->mutually_exclusive_operation_running,
                        1)) {
@@ -3693,7 +3694,7 @@ static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
        if (copy_to_user(arg, p, sizeof(*p)))
                ret = -EFAULT;
+out:
        kfree(p);
        return ret;
 }
@@ -4303,7 +4304,7 @@ static long btrfs_ioctl_quota_rescan_status(struct file *file, void __user *arg)
 static long btrfs_ioctl_quota_rescan_wait(struct file *file, void __user *arg)
 {
-        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
+        struct btrfs_root *root = BTRFS_I(file_inode(file))->root;
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
@@ -4543,9 +4544,15 @@ long btrfs_ioctl(struct file *file, unsigned int
                return btrfs_ioctl_logical_to_ino(root, argp);
        case BTRFS_IOC_SPACE_INFO:
                return btrfs_ioctl_space_info(root, argp);
-        case BTRFS_IOC_SYNC:
+        case BTRFS_IOC_SYNC: {
-                btrfs_sync_fs(file->f_dentry->d_sb, 1);
+                int ret;
-                return 0;
+                ret = btrfs_start_delalloc_roots(root->fs_info, 0);
+                if (ret)
+                        return ret;
+                ret = btrfs_sync_fs(file->f_dentry->d_sb, 1);
+                return ret;
+        }
        case BTRFS_IOC_START_SYNC:
                return btrfs_ioctl_start_sync(root, argp);
        case BTRFS_IOC_WAIT_SYNC:
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 966b413a33b8..69582d5b69d1 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -537,7 +537,9 @@ void btrfs_remove_ordered_extent(struct inode *inode,
         */
        if (RB_EMPTY_ROOT(&tree->tree) &&
            !mapping_tagged(inode->i_mapping, PAGECACHE_TAG_DIRTY)) {
+                spin_lock(&root->fs_info->ordered_root_lock);
                list_del_init(&BTRFS_I(inode)->ordered_operations);
+                spin_unlock(&root->fs_info->ordered_root_lock);
        }
        if (!root->nr_ordered_extents) {
@@ -563,11 +565,11 @@ static void btrfs_run_ordered_extent_work(struct btrfs_work *work)
 * wait for all the ordered extents in a root.  This is done when balancing
 * space between drives.
 */
-void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput)
+int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr)
 {
        struct list_head splice, works;
        struct btrfs_ordered_extent *ordered, *next;
-        struct inode *inode;
+        int count = 0;
        INIT_LIST_HEAD(&splice);
        INIT_LIST_HEAD(&works);
@@ -575,20 +577,11 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput)
        mutex_lock(&root->fs_info->ordered_operations_mutex);
        spin_lock(&root->ordered_extent_lock);
        list_splice_init(&root->ordered_extents, &splice);
-        while (!list_empty(&splice)) {
+        while (!list_empty(&splice) && nr) {
                ordered = list_first_entry(&splice, struct btrfs_ordered_extent,
                                           root_extent_list);
                list_move_tail(&ordered->root_extent_list,
                               &root->ordered_extents);
-                /*
-                 * the inode may be getting freed (in sys_unlink path).
-                 */
-                inode = igrab(ordered->inode);
-                if (!inode) {
-                        cond_resched_lock(&root->ordered_extent_lock);
-                        continue;
-                }
                atomic_inc(&ordered->refs);
                spin_unlock(&root->ordered_extent_lock);
@@ -599,36 +592,35 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput)
                cond_resched();
                spin_lock(&root->ordered_extent_lock);
+                if (nr != -1)
+                        nr--;
+                count++;
        }
+        list_splice_tail(&splice, &root->ordered_extents);
        spin_unlock(&root->ordered_extent_lock);
        list_for_each_entry_safe(ordered, next, &works, work_list) {
                list_del_init(&ordered->work_list);
                wait_for_completion(&ordered->completion);
-                inode = ordered->inode;
                btrfs_put_ordered_extent(ordered);
-                if (delay_iput)
-                        btrfs_add_delayed_iput(inode);
-                else
-                        iput(inode);
                cond_resched();
        }
        mutex_unlock(&root->fs_info->ordered_operations_mutex);
+        return count;
 }
-void btrfs_wait_all_ordered_extents(struct btrfs_fs_info *fs_info,
+void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
-                                    int delay_iput)
 {
        struct btrfs_root *root;
        struct list_head splice;
+        int done;
        INIT_LIST_HEAD(&splice);
        spin_lock(&fs_info->ordered_root_lock);
        list_splice_init(&fs_info->ordered_roots, &splice);
-        while (!list_empty(&splice)) {
+        while (!list_empty(&splice) && nr) {
                root = list_first_entry(&splice, struct btrfs_root,
                                        ordered_root);
                root = btrfs_grab_fs_root(root);
@@ -637,11 +629,16 @@ void btrfs_wait_all_ordered_extents(struct btrfs_fs_info *fs_info,
                               &fs_info->ordered_roots);
                spin_unlock(&fs_info->ordered_root_lock);
-                btrfs_wait_ordered_extents(root, delay_iput);
+                done = btrfs_wait_ordered_extents(root, nr);
                btrfs_put_fs_root(root);
                spin_lock(&fs_info->ordered_root_lock);
+                if (nr != -1) {
+                        nr -= done;
+                        WARN_ON(nr < 0);
+                }
        }
+        list_splice_tail(&splice, &fs_info->ordered_roots);
        spin_unlock(&fs_info->ordered_root_lock);
 }
@@ -752,8 +749,9 @@ void btrfs_start_ordered_extent(struct inode *inode,
 /*
 * Used to wait on ordered extents across a large range of bytes.
 */
-void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
+int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
 {
+        int ret = 0;
        u64 end;
        u64 orig_end;
        struct btrfs_ordered_extent *ordered;
@@ -769,8 +767,9 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
        /* start IO across the range first to instantiate any delalloc
         * extents
         */
-        filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
+        ret = filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
+        if (ret)
+                return ret;
        /*
         * So with compression we will find and lock a dirty page and clear the
         * first one as dirty, setup an async extent, and immediately return
@@ -786,10 +785,15 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
         * right and you are wrong.
         */
        if (test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
-                     &BTRFS_I(inode)->runtime_flags))
+                     &BTRFS_I(inode)->runtime_flags)) {
-                filemap_fdatawrite_range(inode->i_mapping, start, orig_end);
+                ret = filemap_fdatawrite_range(inode->i_mapping, start,
+                                               orig_end);
-        filemap_fdatawait_range(inode->i_mapping, start, orig_end);
+                if (ret)
+                        return ret;
+        }
+        ret = filemap_fdatawait_range(inode->i_mapping, start, orig_end);
+        if (ret)
+                return ret;
        end = orig_end;
        while (1) {
@@ -800,17 +804,20 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
                        btrfs_put_ordered_extent(ordered);
                        break;
                }
-                if (ordered->file_offset + ordered->len < start) {
+                if (ordered->file_offset + ordered->len <= start) {
                        btrfs_put_ordered_extent(ordered);
                        break;
                }
                btrfs_start_ordered_extent(inode, ordered, 1);
                end = ordered->file_offset;
+                if (test_bit(BTRFS_ORDERED_IOERR, &ordered->flags))
+                        ret = -EIO;
                btrfs_put_ordered_extent(ordered);
-                if (end == 0 || end == start)
+                if (ret || end == 0 || end == start)
                        break;
                end--;
        }
+        return ret;
 }
 /*
@@ -1094,7 +1101,7 @@ void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
         * if this file hasn't been changed since the last transaction
         * commit, we can safely return without doing anything
         */
-        if (last_mod < root->fs_info->last_trans_committed)
+        if (last_mod <= root->fs_info->last_trans_committed)
                return;
        spin_lock(&root->fs_info->ordered_root_lock);
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index d9a5aa097b4f..9b0450f7ac20 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -180,7 +180,7 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
                                                         u64 file_offset);
 void btrfs_start_ordered_extent(struct inode *inode,
                                struct btrfs_ordered_extent *entry, int wait);
-void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len);
+int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len);
 struct btrfs_ordered_extent *
 btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset);
 struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode,
@@ -195,9 +195,8 @@ int btrfs_run_ordered_operations(struct btrfs_trans_handle *trans,
 void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root,
                                 struct inode *inode);
-void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput);
+int btrfs_wait_ordered_extents(struct btrfs_root *root, int nr);
-void btrfs_wait_all_ordered_extents(struct btrfs_fs_info *fs_info,
+void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr);
-                                    int delay_iput);
 void btrfs_get_logged_extents(struct btrfs_root *log, struct inode *inode);
 void btrfs_wait_logged_extents(struct btrfs_root *log, u64 transid);
 void btrfs_free_logged_extents(struct btrfs_root *log, u64 transid);
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index 0088bedc8631..417053b17181 100644
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -193,7 +193,7 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
        btrfs_info(root->fs_info, "leaf %llu total ptrs %d free space %d",
                   btrfs_header_bytenr(l), nr, btrfs_leaf_free_space(root, l));
        for (i = 0 ; i < nr ; i++) {
-                item = btrfs_item_nr(l, i);
+                item = btrfs_item_nr(i);
                btrfs_item_key_to_cpu(l, &key, i);
                type = btrfs_key_type(&key);
                printk(KERN_INFO "\titem %d key (%llu %u %llu) itemoff %d "
diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index d0ecfbd9cc9f..24ac21840a9a 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -33,7 +33,6 @@
 #include <linux/raid/xor.h>
 #include <linux/vmalloc.h>
 #include <asm/div64.h>
-#include "compat.h"
 #include "ctree.h"
 #include "extent_map.h"
 #include "disk-io.h"
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index aacc2121e87c..ce459a7cb16d 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -588,7 +588,7 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,
        else
                key.offset = (u64)-1;
-        return btrfs_read_fs_root_no_name(fs_info, &key);
+        return btrfs_get_fs_root(fs_info, &key, false);
 }
 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
@@ -1383,6 +1383,7 @@ int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
 {
        struct btrfs_root *reloc_root;
        struct reloc_control *rc = root->fs_info->reloc_ctl;
+        struct btrfs_block_rsv *rsv;
        int clear_rsv = 0;
        int ret;
@@ -1396,13 +1397,14 @@ int btrfs_init_reloc_root(struct btrfs_trans_handle *trans,
            root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
                return 0;
-        if (!trans->block_rsv) {
+        if (!trans->reloc_reserved) {
+                rsv = trans->block_rsv;
                trans->block_rsv = rc->block_rsv;
                clear_rsv = 1;
        }
        reloc_root = create_reloc_root(trans, root, root->root_key.objectid);
        if (clear_rsv)
-                trans->block_rsv = NULL;
+                trans->block_rsv = rsv;
        ret = __add_reloc_root(reloc_root);
        BUG_ON(ret < 0);
@@ -1548,7 +1550,7 @@ static int get_new_location(struct inode *reloc_inode, u64 *new_bytenr,
               btrfs_file_extent_other_encoding(leaf, fi));
        if (num_bytes != btrfs_file_extent_disk_num_bytes(leaf, fi)) {
-                ret = 1;
+                ret = -EINVAL;
                goto out;
        }
@@ -1579,7 +1581,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
        u64 end;
        u32 nritems;
        u32 i;
-        int ret;
+        int ret = 0;
        int first = 1;
        int dirty = 0;
@@ -1642,11 +1644,13 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
                ret = get_new_location(rc->data_inode, &new_bytenr,
                                       bytenr, num_bytes);
-                if (ret > 0) {
+                if (ret) {
-                        WARN_ON(1);
+                        /*
-                        continue;
+                         * Don't have to abort since we've not changed anything
+                         * in the file extent yet.
+                         */
+                        break;
                }
-                BUG_ON(ret < 0);
                btrfs_set_file_extent_disk_bytenr(leaf, fi, new_bytenr);
                dirty = 1;
@@ -1656,18 +1660,24 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
                                           num_bytes, parent,
                                           btrfs_header_owner(leaf),
                                           key.objectid, key.offset, 1);
-                BUG_ON(ret);
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        break;
+                }
                ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
                                        parent, btrfs_header_owner(leaf),
                                        key.objectid, key.offset, 1);
-                BUG_ON(ret);
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        break;
+                }
        }
        if (dirty)
                btrfs_mark_buffer_dirty(leaf);
        if (inode)
                btrfs_add_delayed_iput(inode);
-        return 0;
+        return ret;
 }
 static noinline_for_stack
@@ -1767,8 +1777,7 @@ again:
                        new_ptr_gen = 0;
                }
-                if (new_bytenr > 0 && new_bytenr == old_bytenr) {
+                if (WARN_ON(new_bytenr > 0 && new_bytenr == old_bytenr)) {
-                        WARN_ON(1);
                        ret = level;
                        break;
                }
@@ -2050,7 +2059,7 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
        LIST_HEAD(inode_list);
        struct btrfs_key key;
        struct btrfs_key next_key;
-        struct btrfs_trans_handle *trans;
+        struct btrfs_trans_handle *trans = NULL;
        struct btrfs_root *reloc_root;
        struct btrfs_root_item *root_item;
        struct btrfs_path *path;
@@ -2099,18 +2108,19 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
        memset(&next_key, 0, sizeof(next_key));
        while (1) {
-                trans = btrfs_start_transaction(root, 0);
-                BUG_ON(IS_ERR(trans));
-                trans->block_rsv = rc->block_rsv;
                ret = btrfs_block_rsv_refill(root, rc->block_rsv, min_reserved,
                                             BTRFS_RESERVE_FLUSH_ALL);
                if (ret) {
-                        BUG_ON(ret != -EAGAIN);
+                        err = ret;
-                        ret = btrfs_commit_transaction(trans, root);
+                        goto out;
-                        BUG_ON(ret);
+                }
-                        continue;
+                trans = btrfs_start_transaction(root, 0);
+                if (IS_ERR(trans)) {
+                        err = PTR_ERR(trans);
+                        trans = NULL;
+                        goto out;
                }
+                trans->block_rsv = rc->block_rsv;
                replaced = 0;
                max_level = level;
@@ -2156,6 +2166,7 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
                root_item->drop_level = level;
                btrfs_end_transaction_throttle(trans, root);
+                trans = NULL;
                btrfs_btree_balance_dirty(root);
@@ -2184,7 +2195,8 @@ out:
                btrfs_update_reloc_root(trans, root);
        }
-        btrfs_end_transaction_throttle(trans, root);
+        if (trans)
+                btrfs_end_transaction_throttle(trans, root);
        btrfs_btree_balance_dirty(root);
@@ -3250,7 +3262,7 @@ static int add_tree_block(struct reloc_control *rc,
        struct rb_node *rb_node;
        u32 item_size;
        int level = -1;
-        int generation;
+        u64 generation;
        eb =  path->nodes[0];
        item_size = btrfs_item_size_nr(eb, path->slots[0]);
@@ -3399,7 +3411,6 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info,
                                    struct inode *inode, u64 ino)
 {
        struct btrfs_key key;
-        struct btrfs_path *path;
        struct btrfs_root *root = fs_info->tree_root;
        struct btrfs_trans_handle *trans;
        int ret = 0;
@@ -3424,22 +3435,14 @@ truncate:
        if (ret)
                goto out;
-        path = btrfs_alloc_path();
-        if (!path) {
-                ret = -ENOMEM;
-                goto out;
-        }
        trans = btrfs_join_transaction(root);
        if (IS_ERR(trans)) {
-                btrfs_free_path(path);
                ret = PTR_ERR(trans);
                goto out;
        }
-        ret = btrfs_truncate_free_space_cache(root, trans, path, inode);
+        ret = btrfs_truncate_free_space_cache(root, trans, inode);
-        btrfs_free_path(path);
        btrfs_end_transaction(trans, root);
        btrfs_btree_balance_dirty(root);
 out:
@@ -3541,10 +3544,8 @@ static int find_data_references(struct reloc_control *rc,
                                err = ret;
                                goto out;
                        }
-                        if (ret > 0) {
+                        if (WARN_ON(ret > 0))
-                                WARN_ON(1);
                                goto out;
-                        }
                        leaf = path->nodes[0];
                        nritems = btrfs_header_nritems(leaf);
@@ -3564,11 +3565,9 @@ static int find_data_references(struct reloc_control *rc,
                }
                btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
-                if (key.objectid != ref_objectid ||
+                if (WARN_ON(key.objectid != ref_objectid ||
-                    key.type != BTRFS_EXTENT_DATA_KEY) {
+                    key.type != BTRFS_EXTENT_DATA_KEY))
-                        WARN_ON(1);
                        break;
-                }
                fi = btrfs_item_ptr(leaf, path->slots[0],
                                    struct btrfs_file_extent_item);
@@ -3993,16 +3992,6 @@ restart:
                        }
                }
-                ret = btrfs_block_rsv_check(rc->extent_root, rc->block_rsv, 5);
-                if (ret < 0) {
-                        if (ret != -ENOSPC) {
-                                err = ret;
-                                WARN_ON(1);
-                                break;
-                        }
-                        rc->commit_transaction = 1;
-                }
                if (rc->commit_transaction) {
                        rc->commit_transaction = 0;
                        ret = btrfs_commit_transaction(trans, rc->extent_root);
@@ -4233,12 +4222,12 @@ int btrfs_relocate_block_group(struct btrfs_root *extent_root, u64 group_start)
        printk(KERN_INFO "btrfs: relocating block group %llu flags %llu\n",
               rc->block_group->key.objectid, rc->block_group->flags);
-        ret = btrfs_start_all_delalloc_inodes(fs_info, 0);
+        ret = btrfs_start_delalloc_roots(fs_info, 0);
        if (ret < 0) {
                err = ret;
                goto out;
        }
-        btrfs_wait_all_ordered_extents(fs_info, 0);
+        btrfs_wait_ordered_roots(fs_info, -1);
        while (1) {
                mutex_lock(&fs_info->cleaner_mutex);
@@ -4256,7 +4245,12 @@ int btrfs_relocate_block_group(struct btrfs_root *extent_root, u64 group_start)
                        rc->extents_found);
                if (rc->stage == MOVE_DATA_EXTENTS && rc->found_file_extent) {
-                        btrfs_wait_ordered_range(rc->data_inode, 0, (u64)-1);
+                        ret = btrfs_wait_ordered_range(rc->data_inode, 0,
+                                                       (u64)-1);
+                        if (ret) {
+                                err = ret;
+                                goto out;
+                        }
                        invalidate_mapping_pages(rc->data_inode->i_mapping,
                                                 0, -1);
                        rc->stage = UPDATE_DATA_PTRS;
@@ -4473,6 +4467,7 @@ int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len)
        struct btrfs_root *root = BTRFS_I(inode)->root;
        int ret;
        u64 disk_bytenr;
+        u64 new_bytenr;
        LIST_HEAD(list);
        ordered = btrfs_lookup_ordered_extent(inode, file_pos);
@@ -4484,13 +4479,24 @@ int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len)
        if (ret)
                goto out;
-        disk_bytenr = ordered->start;
        while (!list_empty(&list)) {
                sums = list_entry(list.next, struct btrfs_ordered_sum, list);
                list_del_init(&sums->list);
-                sums->bytenr = disk_bytenr;
+                /*
-                disk_bytenr += sums->len;
+                 * We need to offset the new_bytenr based on where the csum is.
+                 * We need to do this because we will read in entire prealloc
+                 * extents but we may have written to say the middle of the
+                 * prealloc extent, so we need to make sure the csum goes with
+                 * the right disk offset.
+                 *
+                 * We can do this because the data reloc inode refers strictly
+                 * to the on disk bytes, so we don't have to worry about
+                 * disk_len vs real len like with real inodes since it's all
+                 * disk length.
+                 */
+                new_bytenr = ordered->start + (sums->bytenr - disk_bytenr);
+                sums->bytenr = new_bytenr;
                btrfs_add_ordered_sum(inode, ordered, sums);
        }
@@ -4499,19 +4505,19 @@ out:
        return ret;
 }
-void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
+int btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
-                           struct btrfs_root *root, struct extent_buffer *buf,
+                          struct btrfs_root *root, struct extent_buffer *buf,
-                           struct extent_buffer *cow)
+                          struct extent_buffer *cow)
 {
        struct reloc_control *rc;
        struct backref_node *node;
        int first_cow = 0;
        int level;
-        int ret;
+        int ret = 0;
        rc = root->fs_info->reloc_ctl;
        if (!rc)
-                return;
+                return 0;
        BUG_ON(rc->stage == UPDATE_DATA_PTRS &&
               root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID);
@@ -4547,10 +4553,9 @@ void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans,
                        rc->nodes_relocated += buf->len;
        }
-        if (level == 0 && first_cow && rc->stage == UPDATE_DATA_PTRS) {
+        if (level == 0 && first_cow && rc->stage == UPDATE_DATA_PTRS)
                ret = replace_file_extents(trans, rc, root, cow);
-                BUG_ON(ret);
+        return ret;
-        }
 }
 /*
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 0b1f4ef8db98..ec71ea44d2b4 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -299,11 +299,6 @@ int btrfs_find_orphan_roots(struct btrfs_root *tree_root)
                        continue;
                }
-                if (btrfs_root_refs(&root->root_item) == 0) {
-                        btrfs_add_dead_root(root);
-                        continue;
-                }
                err = btrfs_init_fs_root(root);
                if (err) {
                        btrfs_free_fs_root(root);
@@ -318,6 +313,9 @@ int btrfs_find_orphan_roots(struct btrfs_root *tree_root)
                        btrfs_free_fs_root(root);
                        break;
                }
+                if (btrfs_root_refs(&root->root_item) == 0)
+                        btrfs_add_dead_root(root);
        }
        btrfs_free_path(path);
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 0afcd452fcb3..561e2f16ba3e 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -158,12 +158,20 @@ struct scrub_fixup_nodatasum {
        int                     mirror_num;
 };
+struct scrub_nocow_inode {
+        u64                     inum;
+        u64                     offset;
+        u64                     root;
+        struct list_head        list;
+};
 struct scrub_copy_nocow_ctx {
        struct scrub_ctx        *sctx;
        u64                     logical;
        u64                     len;
        int                     mirror_num;
        u64                     physical_for_dev_replace;
+        struct list_head        inodes;
        struct btrfs_work       work;
 };
@@ -245,7 +253,7 @@ static void scrub_wr_bio_end_io_worker(struct btrfs_work *work);
 static int write_page_nocow(struct scrub_ctx *sctx,
                            u64 physical_for_dev_replace, struct page *page);
 static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
-                                      void *ctx);
+                                      struct scrub_copy_nocow_ctx *ctx);
 static int copy_nocow_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
                            int mirror_num, u64 physical_for_dev_replace);
 static void copy_nocow_pages_worker(struct btrfs_work *work);
@@ -930,8 +938,10 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                                BTRFS_DEV_STAT_CORRUPTION_ERRS);
        }
-        if (sctx->readonly && !sctx->is_dev_replace)
+        if (sctx->readonly) {
-                goto did_not_correct_error;
+                ASSERT(!sctx->is_dev_replace);
+                goto out;
+        }
        if (!is_metadata && !have_csum) {
                struct scrub_fixup_nodatasum *fixup_nodatasum;
@@ -2709,8 +2719,6 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                mutex_unlock(&fs_info->scrub_lock);
                wake_up(&fs_info->scrub_pause_wait);
-                dev_replace->cursor_left = dev_replace->cursor_right;
-                dev_replace->item_needs_writeback = 1;
                btrfs_put_block_group(cache);
                if (ret)
                        break;
@@ -2724,6 +2732,9 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                        break;
                }
+                dev_replace->cursor_left = dev_replace->cursor_right;
+                dev_replace->item_needs_writeback = 1;
                key.offset = found_key.offset + length;
                btrfs_release_path(path);
        }
@@ -2775,7 +2786,6 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
 {
        int ret = 0;
-        mutex_lock(&fs_info->scrub_lock);
        if (fs_info->scrub_workers_refcnt == 0) {
                if (is_dev_replace)
                        btrfs_init_workers(&fs_info->scrub_workers, "scrub", 1,
@@ -2805,21 +2815,17 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
        }
        ++fs_info->scrub_workers_refcnt;
 out:
-        mutex_unlock(&fs_info->scrub_lock);
        return ret;
 }
 static noinline_for_stack void scrub_workers_put(struct btrfs_fs_info *fs_info)
 {
-        mutex_lock(&fs_info->scrub_lock);
        if (--fs_info->scrub_workers_refcnt == 0) {
                btrfs_stop_workers(&fs_info->scrub_workers);
                btrfs_stop_workers(&fs_info->scrub_wr_completion_workers);
                btrfs_stop_workers(&fs_info->scrub_nocow_workers);
        }
        WARN_ON(fs_info->scrub_workers_refcnt < 0);
-        mutex_unlock(&fs_info->scrub_lock);
 }
 int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
@@ -2880,23 +2886,18 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
                return -EINVAL;
        }
-        ret = scrub_workers_get(fs_info, is_dev_replace);
-        if (ret)
-                return ret;
        mutex_lock(&fs_info->fs_devices->device_list_mutex);
        dev = btrfs_find_device(fs_info, devid, NULL, NULL);
        if (!dev || (dev->missing && !is_dev_replace)) {
                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                return -ENODEV;
        }
-        mutex_lock(&fs_info->scrub_lock);
+        mutex_lock(&fs_info->scrub_lock);
        if (!dev->in_fs_metadata || dev->is_tgtdev_for_dev_replace) {
                mutex_unlock(&fs_info->scrub_lock);
                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                return -EIO;
        }
@@ -2907,10 +2908,17 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
                btrfs_dev_replace_unlock(&fs_info->dev_replace);
                mutex_unlock(&fs_info->scrub_lock);
                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(fs_info);
                return -EINPROGRESS;
        }
        btrfs_dev_replace_unlock(&fs_info->dev_replace);
+        ret = scrub_workers_get(fs_info, is_dev_replace);
+        if (ret) {
+                mutex_unlock(&fs_info->scrub_lock);
+                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+                return ret;
+        }
        sctx = scrub_setup_ctx(dev, is_dev_replace);
        if (IS_ERR(sctx)) {
                mutex_unlock(&fs_info->scrub_lock);
@@ -2923,13 +2931,15 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
        atomic_inc(&fs_info->scrubs_running);
        mutex_unlock(&fs_info->scrub_lock);
-        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
        if (!is_dev_replace) {
-                down_read(&fs_info->scrub_super_lock);
+                /*
+                 * by holding device list mutex, we can
+                 * kick off writing super in log tree sync.
+                 */
                ret = scrub_supers(sctx, dev);
-                up_read(&fs_info->scrub_super_lock);
        }
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
        if (!ret)
                ret = scrub_enumerate_chunks(sctx, dev, start, end,
@@ -2946,10 +2956,10 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
        mutex_lock(&fs_info->scrub_lock);
        dev->scrub_device = NULL;
+        scrub_workers_put(fs_info);
        mutex_unlock(&fs_info->scrub_lock);
        scrub_free_ctx(sctx);
-        scrub_workers_put(fs_info);
        return ret;
 }
@@ -2979,16 +2989,6 @@ void btrfs_scrub_continue(struct btrfs_root *root)
        wake_up(&fs_info->scrub_pause_wait);
 }
-void btrfs_scrub_pause_super(struct btrfs_root *root)
-{
-        down_write(&root->fs_info->scrub_super_lock);
-}
-void btrfs_scrub_continue_super(struct btrfs_root *root)
-{
-        up_write(&root->fs_info->scrub_super_lock);
-}
 int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)
 {
        mutex_lock(&fs_info->scrub_lock);
@@ -3126,12 +3126,30 @@ static int copy_nocow_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
        nocow_ctx->mirror_num = mirror_num;
        nocow_ctx->physical_for_dev_replace = physical_for_dev_replace;
        nocow_ctx->work.func = copy_nocow_pages_worker;
+        INIT_LIST_HEAD(&nocow_ctx->inodes);
        btrfs_queue_worker(&fs_info->scrub_nocow_workers,
                           &nocow_ctx->work);
        return 0;
 }
+static int record_inode_for_nocow(u64 inum, u64 offset, u64 root, void *ctx)
+{
+        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
+        struct scrub_nocow_inode *nocow_inode;
+        nocow_inode = kzalloc(sizeof(*nocow_inode), GFP_NOFS);
+        if (!nocow_inode)
+                return -ENOMEM;
+        nocow_inode->inum = inum;
+        nocow_inode->offset = offset;
+        nocow_inode->root = root;
+        list_add_tail(&nocow_inode->list, &nocow_ctx->inodes);
+        return 0;
+}
+#define COPY_COMPLETE 1
 static void copy_nocow_pages_worker(struct btrfs_work *work)
 {
        struct scrub_copy_nocow_ctx *nocow_ctx =
@@ -3167,8 +3185,7 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
        }
        ret = iterate_inodes_from_logical(logical, fs_info, path,
-                                          copy_nocow_pages_for_inode,
+                                          record_inode_for_nocow, nocow_ctx);
-                                          nocow_ctx);
        if (ret != 0 && ret != -ENOENT) {
                pr_warn("iterate_inodes_from_logical() failed: log %llu, phys %llu, len %llu, mir %u, ret %d\n",
                        logical, physical_for_dev_replace, len, mirror_num,
@@ -3177,7 +3194,33 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
                goto out;
        }
+        btrfs_end_transaction(trans, root);
+        trans = NULL;
+        while (!list_empty(&nocow_ctx->inodes)) {
+                struct scrub_nocow_inode *entry;
+                entry = list_first_entry(&nocow_ctx->inodes,
+                                         struct scrub_nocow_inode,
+                                         list);
+                list_del_init(&entry->list);
+                ret = copy_nocow_pages_for_inode(entry->inum, entry->offset,
+                                                 entry->root, nocow_ctx);
+                kfree(entry);
+                if (ret == COPY_COMPLETE) {
+                        ret = 0;
+                        break;
+                } else if (ret) {
+                        break;
+                }
+        }
 out:
+        while (!list_empty(&nocow_ctx->inodes)) {
+                struct scrub_nocow_inode *entry;
+                entry = list_first_entry(&nocow_ctx->inodes,
+                                         struct scrub_nocow_inode,
+                                         list);
+                list_del_init(&entry->list);
+                kfree(entry);
+        }
        if (trans && !IS_ERR(trans))
                btrfs_end_transaction(trans, root);
        if (not_written)
@@ -3190,20 +3233,25 @@ out:
        scrub_pending_trans_workers_dec(sctx);
 }
-static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
+static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root,
+                                      struct scrub_copy_nocow_ctx *nocow_ctx)
 {
-        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
        struct btrfs_fs_info *fs_info = nocow_ctx->sctx->dev_root->fs_info;
        struct btrfs_key key;
        struct inode *inode;
        struct page *page;
        struct btrfs_root *local_root;
+        struct btrfs_ordered_extent *ordered;
+        struct extent_map *em;
+        struct extent_state *cached_state = NULL;
+        struct extent_io_tree *io_tree;
        u64 physical_for_dev_replace;
-        u64 len;
+        u64 len = nocow_ctx->len;
+        u64 lockstart = offset, lockend = offset + len - 1;
        unsigned long index;
        int srcu_index;
-        int ret;
+        int ret = 0;
-        int err;
+        int err = 0;
        key.objectid = root;
        key.type = BTRFS_ROOT_ITEM_KEY;
@@ -3229,9 +3277,33 @@ static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
        mutex_lock(&inode->i_mutex);
        inode_dio_wait(inode);
-        ret = 0;
        physical_for_dev_replace = nocow_ctx->physical_for_dev_replace;
-        len = nocow_ctx->len;
+        io_tree = &BTRFS_I(inode)->io_tree;
+        lock_extent_bits(io_tree, lockstart, lockend, 0, &cached_state);
+        ordered = btrfs_lookup_ordered_range(inode, lockstart, len);
+        if (ordered) {
+                btrfs_put_ordered_extent(ordered);
+                goto out_unlock;
+        }
+        em = btrfs_get_extent(inode, NULL, 0, lockstart, len, 0);
+        if (IS_ERR(em)) {
+                ret = PTR_ERR(em);
+                goto out_unlock;
+        }
+        /*
+         * This extent does not actually cover the logical extent anymore,
+         * move on to the next inode.
+         */
+        if (em->block_start > nocow_ctx->logical ||
+            em->block_start + em->block_len < nocow_ctx->logical + len) {
+                free_extent_map(em);
+                goto out_unlock;
+        }
+        free_extent_map(em);
        while (len >= PAGE_CACHE_SIZE) {
                index = offset >> PAGE_CACHE_SHIFT;
 again:
@@ -3247,10 +3319,9 @@ again:
                                goto next_page;
                } else {
                        ClearPageError(page);
-                        err = extent_read_full_page(&BTRFS_I(inode)->
+                        err = extent_read_full_page_nolock(io_tree, page,
-                                                         io_tree,
+                                                           btrfs_get_extent,
-                                                        page, btrfs_get_extent,
+                                                           nocow_ctx->mirror_num);
-                                                        nocow_ctx->mirror_num);
                        if (err) {
                                ret = err;
                                goto next_page;
@@ -3264,6 +3335,7 @@ again:
                         * page in the page cache.
                         */
                        if (page->mapping != inode->i_mapping) {
+                                unlock_page(page);
                                page_cache_release(page);
                                goto again;
                        }
@@ -3287,6 +3359,10 @@ next_page:
                physical_for_dev_replace += PAGE_CACHE_SIZE;
                len -= PAGE_CACHE_SIZE;
        }
+        ret = COPY_COMPLETE;
+out_unlock:
+        unlock_extent_cached(io_tree, lockstart, lockend, &cached_state,
+                             GFP_NOFS);
 out:
        mutex_unlock(&inode->i_mutex);
        iput(inode);
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index e46e0ed74925..6837fe87f3a6 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -121,7 +121,6 @@ struct send_ctx {
        struct list_head name_cache_list;
        int name_cache_size;
-        struct file *cur_inode_filp;
        char *read_buf;
 };
@@ -565,10 +564,8 @@ static int begin_cmd(struct send_ctx *sctx, int cmd)
 {
        struct btrfs_cmd_header *hdr;
-        if (!sctx->send_buf) {
+        if (WARN_ON(!sctx->send_buf))
-                WARN_ON(1);
                return -EINVAL;
-        }
        BUG_ON(sctx->send_size);
@@ -791,7 +788,7 @@ static int iterate_inode_ref(struct btrfs_root *root, struct btrfs_path *path,
        if (found_key->type == BTRFS_INODE_REF_KEY) {
                ptr = (unsigned long)btrfs_item_ptr(eb, slot,
                                                    struct btrfs_inode_ref);
-                item = btrfs_item_nr(eb, slot);
+                item = btrfs_item_nr(slot);
                total = btrfs_item_size(eb, item);
                elem_size = sizeof(*iref);
        } else {
@@ -905,7 +902,7 @@ static int iterate_dir_item(struct btrfs_root *root, struct btrfs_path *path,
        eb = path->nodes[0];
        slot = path->slots[0];
-        item = btrfs_item_nr(eb, slot);
+        item = btrfs_item_nr(slot);
        di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
        cur = 0;
        len = 0;
@@ -2120,77 +2117,6 @@ out:
 }
 /*
- * Called for regular files when sending extents data. Opens a struct file
- * to read from the file.
- */
-static int open_cur_inode_file(struct send_ctx *sctx)
-{
-        int ret = 0;
-        struct btrfs_key key;
-        struct path path;
-        struct inode *inode;
-        struct dentry *dentry;
-        struct file *filp;
-        int new = 0;
-        if (sctx->cur_inode_filp)
-                goto out;
-        key.objectid = sctx->cur_ino;
-        key.type = BTRFS_INODE_ITEM_KEY;
-        key.offset = 0;
-        inode = btrfs_iget(sctx->send_root->fs_info->sb, &key, sctx->send_root,
-                        &new);
-        if (IS_ERR(inode)) {
-                ret = PTR_ERR(inode);
-                goto out;
-        }
-        dentry = d_obtain_alias(inode);
-        inode = NULL;
-        if (IS_ERR(dentry)) {
-                ret = PTR_ERR(dentry);
-                goto out;
-        }
-        path.mnt = sctx->mnt;
-        path.dentry = dentry;
-        filp = dentry_open(&path, O_RDONLY | O_LARGEFILE, current_cred());
-        dput(dentry);
-        dentry = NULL;
-        if (IS_ERR(filp)) {
-                ret = PTR_ERR(filp);
-                goto out;
-        }
-        sctx->cur_inode_filp = filp;
-out:
-        /*
-         * no xxxput required here as every vfs op
-         * does it by itself on failure
-         */
-        return ret;
-}
-/*
- * Closes the struct file that was created in open_cur_inode_file
- */
-static int close_cur_inode_file(struct send_ctx *sctx)
-{
-        int ret = 0;
-        if (!sctx->cur_inode_filp)
-                goto out;
-        ret = filp_close(sctx->cur_inode_filp, NULL);
-        sctx->cur_inode_filp = NULL;
-out:
-        return ret;
-}
-/*
 * Sends a BTRFS_SEND_C_SUBVOL command/item to userspace
 */
 static int send_subvol_begin(struct send_ctx *sctx)
@@ -3622,6 +3548,72 @@ out:
        return ret;
 }
+static ssize_t fill_read_buf(struct send_ctx *sctx, u64 offset, u32 len)
+{
+        struct btrfs_root *root = sctx->send_root;
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct inode *inode;
+        struct page *page;
+        char *addr;
+        struct btrfs_key key;
+        pgoff_t index = offset >> PAGE_CACHE_SHIFT;
+        pgoff_t last_index;
+        unsigned pg_offset = offset & ~PAGE_CACHE_MASK;
+        ssize_t ret = 0;
+        key.objectid = sctx->cur_ino;
+        key.type = BTRFS_INODE_ITEM_KEY;
+        key.offset = 0;
+        inode = btrfs_iget(fs_info->sb, &key, root, NULL);
+        if (IS_ERR(inode))
+                return PTR_ERR(inode);
+        if (offset + len > i_size_read(inode)) {
+                if (offset > i_size_read(inode))
+                        len = 0;
+                else
+                        len = offset - i_size_read(inode);
+        }
+        if (len == 0)
+                goto out;
+        last_index = (offset + len - 1) >> PAGE_CACHE_SHIFT;
+        while (index <= last_index) {
+                unsigned cur_len = min_t(unsigned, len,
+                                         PAGE_CACHE_SIZE - pg_offset);
+                page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
+                if (!page) {
+                        ret = -ENOMEM;
+                        break;
+                }
+                if (!PageUptodate(page)) {
+                        btrfs_readpage(NULL, page);
+                        lock_page(page);
+                        if (!PageUptodate(page)) {
+                                unlock_page(page);
+                                page_cache_release(page);
+                                ret = -EIO;
+                                break;
+                        }
+                }
+                addr = kmap(page);
+                memcpy(sctx->read_buf + ret, addr + pg_offset, cur_len);
+                kunmap(page);
+                unlock_page(page);
+                page_cache_release(page);
+                index++;
+                pg_offset = 0;
+                len -= cur_len;
+                ret += cur_len;
+        }
+out:
+        iput(inode);
+        return ret;
+}
 /*
 * Read some bytes from the current inode/file and send a write command to
 * user space.
@@ -3630,35 +3622,20 @@ static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
 {
        int ret = 0;
        struct fs_path *p;
-        loff_t pos = offset;
+        ssize_t num_read = 0;
-        int num_read = 0;
-        mm_segment_t old_fs;
        p = fs_path_alloc();
        if (!p)
                return -ENOMEM;
-        /*
-         * vfs normally only accepts user space buffers for security reasons.
-         * we only read from the file and also only provide the read_buf buffer
-         * to vfs. As this buffer does not come from a user space call, it's
-         * ok to temporary allow kernel space buffers.
-         */
-        old_fs = get_fs();
-        set_fs(KERNEL_DS);
 verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
-        ret = open_cur_inode_file(sctx);
+        num_read = fill_read_buf(sctx, offset, len);
-        if (ret < 0)
+        if (num_read <= 0) {
-                goto out;
+                if (num_read < 0)
+                        ret = num_read;
-        ret = vfs_read(sctx->cur_inode_filp, sctx->read_buf, len, &pos);
-        if (ret < 0)
-                goto out;
-        num_read = ret;
-        if (!num_read)
                goto out;
+        }
        ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
        if (ret < 0)
@@ -3677,7 +3654,6 @@ verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
 tlv_put_failure:
 out:
        fs_path_free(p);
-        set_fs(old_fs);
        if (ret < 0)
                return ret;
        return num_read;
@@ -3926,16 +3902,16 @@ static int is_extent_unchanged(struct send_ctx *sctx,
        while (key.offset < ekey->offset + left_len) {
                ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
                right_type = btrfs_file_extent_type(eb, ei);
-                right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
-                right_len = btrfs_file_extent_num_bytes(eb, ei);
-                right_offset = btrfs_file_extent_offset(eb, ei);
-                right_gen = btrfs_file_extent_generation(eb, ei);
                if (right_type != BTRFS_FILE_EXTENT_REG) {
                        ret = 0;
                        goto out;
                }
+                right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
+                right_len = btrfs_file_extent_num_bytes(eb, ei);
+                right_offset = btrfs_file_extent_offset(eb, ei);
+                right_gen = btrfs_file_extent_generation(eb, ei);
                /*
                 * Are we at extent 8? If yes, we know the extent is changed.
                 * This may only happen on the first iteration.
@@ -4222,10 +4198,6 @@ static int changed_inode(struct send_ctx *sctx,
        u64 left_gen = 0;
        u64 right_gen = 0;
-        ret = close_cur_inode_file(sctx);
-        if (ret < 0)
-                goto out;
        sctx->cur_ino = key->objectid;
        sctx->cur_inode_new_gen = 0;
@@ -4686,11 +4658,6 @@ static int send_subvol(struct send_ctx *sctx)
        }
 out:
-        if (!ret)
-                ret = close_cur_inode_file(sctx);
-        else
-                close_cur_inode_file(sctx);
        free_recorded_refs(sctx);
        return ret;
 }
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 3aab10ce63e8..2d8ac1bf0cf9 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -42,7 +42,6 @@
 #include <linux/cleancache.h>
 #include <linux/ratelimit.h>
 #include <linux/btrfs.h>
-#include "compat.h"
 #include "delayed-inode.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -921,7 +920,7 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
                return 0;
        }
-        btrfs_wait_all_ordered_extents(fs_info, 1);
+        btrfs_wait_ordered_roots(fs_info, -1);
        trans = btrfs_attach_transaction_barrier(root);
        if (IS_ERR(trans)) {
@@ -1330,6 +1329,12 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                 * this also happens on 'umount -rf' or on shutdown, when
                 * the filesystem is busy.
                 */
+                /* wait for the uuid_scan task to finish */
+                down(&fs_info->uuid_tree_rescan_sem);
+                /* avoid complains from lockdep et al. */
+                up(&fs_info->uuid_tree_rescan_sem);
                sb->s_flags |= MS_RDONLY;
                btrfs_dev_replace_suspend_for_unmount(fs_info);
@@ -1340,6 +1345,12 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                if (ret)
                        goto restore;
        } else {
+                if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
+                        btrfs_err(fs_info,
+                                "Remounting read-write after error is not allowed\n");
+                        ret = -EINVAL;
+                        goto restore;
+                }
                if (fs_info->fs_devices->rw_devices == 0) {
                        ret = -EACCES;
                        goto restore;
@@ -1377,6 +1388,16 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                        pr_warn("btrfs: failed to resume dev_replace\n");
                        goto restore;
                }
+                if (!fs_info->uuid_root) {
+                        pr_info("btrfs: creating UUID tree\n");
+                        ret = btrfs_create_uuid_tree(fs_info);
+                        if (ret) {
+                                pr_warn("btrfs: failed to create the uuid tree"
+                                        "%d\n", ret);
+                                goto restore;
+                        }
+                }
                sb->s_flags &= ~MS_RDONLY;
        }
 out:
@@ -1449,7 +1470,7 @@ static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
        nr_devices = fs_info->fs_devices->open_devices;
        BUG_ON(!nr_devices);
-        devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
+        devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
                               GFP_NOFS);
        if (!devices_info)
                return -ENOMEM;
@@ -1762,6 +1783,9 @@ static void btrfs_print_info(void)
 #ifdef CONFIG_BTRFS_DEBUG
                        ", debug=on"
 #endif
+#ifdef CONFIG_BTRFS_ASSERT
+                        ", assert=on"
+#endif
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
                        ", integrity-checker=on"
 #endif
@@ -1770,7 +1794,25 @@ static void btrfs_print_info(void)
 static int btrfs_run_sanity_tests(void)
 {
-        return btrfs_test_free_space_cache();
+        int ret;
+        ret = btrfs_init_test_fs();
+        if (ret)
+                return ret;
+        ret = btrfs_test_free_space_cache();
+        if (ret)
+                goto out;
+        ret = btrfs_test_extent_buffer_operations();
+        if (ret)
+                goto out;
+        ret = btrfs_test_extent_io();
+        if (ret)
+                goto out;
+        ret = btrfs_test_inodes();
+out:
+        btrfs_destroy_test_fs();
+        return ret;
 }
 static int __init init_btrfs_fs(void)
diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c
new file mode 100644
index 000000000000..757ef00a75a4
--- /dev/null
+++ b/fs/btrfs/tests/btrfs-tests.c
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2013 Fusion IO.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#include <linux/fs.h>
+#include <linux/mount.h>
+#include <linux/magic.h>
+#include "btrfs-tests.h"
+#include "../ctree.h"
+static struct vfsmount *test_mnt = NULL;
+static const struct super_operations btrfs_test_super_ops = {
+        .alloc_inode    = btrfs_alloc_inode,
+        .destroy_inode  = btrfs_test_destroy_inode,
+};
+static struct dentry *btrfs_test_mount(struct file_system_type *fs_type,
+                                       int flags, const char *dev_name,
+                                       void *data)
+{
+        return mount_pseudo(fs_type, "btrfs_test:", &btrfs_test_super_ops,
+                            NULL, BTRFS_TEST_MAGIC);
+}
+static struct file_system_type test_type = {
+        .name           = "btrfs_test_fs",
+        .mount          = btrfs_test_mount,
+        .kill_sb        = kill_anon_super,
+};
+struct inode *btrfs_new_test_inode(void)
+{
+        return new_inode(test_mnt->mnt_sb);
+}
+int btrfs_init_test_fs(void)
+{
+        int ret;
+        ret = register_filesystem(&test_type);
+        if (ret) {
+                printk(KERN_ERR "btrfs: cannot register test file system\n");
+                return ret;
+        }
+        test_mnt = kern_mount(&test_type);
+        if (IS_ERR(test_mnt)) {
+                printk(KERN_ERR "btrfs: cannot mount test file system\n");
+                unregister_filesystem(&test_type);
+                return ret;
+        }
+        return 0;
+}
+void btrfs_destroy_test_fs(void)
+{
+        kern_unmount(test_mnt);
+        unregister_filesystem(&test_type);
+}
diff --git a/fs/btrfs/tests/btrfs-tests.h b/fs/btrfs/tests/btrfs-tests.h
index 580877625776..b353bc806ca0 100644
--- a/fs/btrfs/tests/btrfs-tests.h
+++ b/fs/btrfs/tests/btrfs-tests.h
@@ -24,11 +24,36 @@
 #define test_msg(fmt, ...) pr_info("btrfs: selftest: " fmt, ##__VA_ARGS__)
 int btrfs_test_free_space_cache(void);
+int btrfs_test_extent_buffer_operations(void);
+int btrfs_test_extent_io(void);
+int btrfs_test_inodes(void);
+int btrfs_init_test_fs(void);
+void btrfs_destroy_test_fs(void);
+struct inode *btrfs_new_test_inode(void);
 #else
 static inline int btrfs_test_free_space_cache(void)
 {
        return 0;
 }
+static inline int btrfs_test_extent_buffer_operations(void)
+{
+        return 0;
+}
+static inline int btrfs_init_test_fs(void)
+{
+        return 0;
+}
+static inline void btrfs_destroy_test_fs(void)
+{
+}
+static inline int btrfs_test_extent_io(void)
+{
+        return 0;
+}
+static inline int btrfs_test_inodes(void)
+{
+        return 0;
+}
 #endif
 #endif
diff --git a/fs/btrfs/tests/extent-buffer-tests.c b/fs/btrfs/tests/extent-buffer-tests.c
new file mode 100644
index 000000000000..cc286ce97d1e
--- /dev/null
+++ b/fs/btrfs/tests/extent-buffer-tests.c
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2013 Fusion IO.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#include <linux/slab.h>
+#include "btrfs-tests.h"
+#include "../ctree.h"
+#include "../extent_io.h"
+#include "../disk-io.h"
+static int test_btrfs_split_item(void)
+{
+        struct btrfs_path *path;
+        struct btrfs_root *root;
+        struct extent_buffer *eb;
+        struct btrfs_item *item;
+        char *value = "mary had a little lamb";
+        char *split1 = "mary had a little";
+        char *split2 = " lamb";
+        char *split3 = "mary";
+        char *split4 = " had a little";
+        char buf[32];
+        struct btrfs_key key;
+        u32 value_len = strlen(value);
+        int ret = 0;
+        test_msg("Running btrfs_split_item tests\n");
+        root = btrfs_alloc_dummy_root();
+        if (IS_ERR(root)) {
+                test_msg("Could not allocate root\n");
+                return PTR_ERR(root);
+        }
+        path = btrfs_alloc_path();
+        if (!path) {
+                test_msg("Could not allocate path\n");
+                kfree(root);
+                return -ENOMEM;
+        }
+        path->nodes[0] = eb = alloc_dummy_extent_buffer(0, 4096);
+        if (!eb) {
+                test_msg("Could not allocate dummy buffer\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+        path->slots[0] = 0;
+        key.objectid = 0;
+        key.type = BTRFS_EXTENT_CSUM_KEY;
+        key.offset = 0;
+        setup_items_for_insert(root, path, &key, &value_len, value_len,
+                               value_len + sizeof(struct btrfs_item), 1);
+        item = btrfs_item_nr(0);
+        write_extent_buffer(eb, value, btrfs_item_ptr_offset(eb, 0),
+                            value_len);
+        key.offset = 3;
+        /*
+         * Passing NULL trans here should be safe because we have plenty of
+         * space in this leaf to split the item without having to split the
+         * leaf.
+         */
+        ret = btrfs_split_item(NULL, root, path, &key, 17);
+        if (ret) {
+                test_msg("Split item failed %d\n", ret);
+                goto out;
+        }
+        /*
+         * Read the first slot, it should have the original key and contain only
+         * 'mary had a little'
+         */
+        btrfs_item_key_to_cpu(eb, &key, 0);
+        if (key.objectid != 0 || key.type != BTRFS_EXTENT_CSUM_KEY ||
+            key.offset != 0) {
+                test_msg("Invalid key at slot 0\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        item = btrfs_item_nr(0);
+        if (btrfs_item_size(eb, item) != strlen(split1)) {
+                test_msg("Invalid len in the first split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        read_extent_buffer(eb, buf, btrfs_item_ptr_offset(eb, 0),
+                           strlen(split1));
+        if (memcmp(buf, split1, strlen(split1))) {
+                test_msg("Data in the buffer doesn't match what it should "
+                         "in the first split have='%.*s' want '%s'\n",
+                         (int)strlen(split1), buf, split1);
+                ret = -EINVAL;
+                goto out;
+        }
+        btrfs_item_key_to_cpu(eb, &key, 1);
+        if (key.objectid != 0 || key.type != BTRFS_EXTENT_CSUM_KEY ||
+            key.offset != 3) {
+                test_msg("Invalid key at slot 1\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        item = btrfs_item_nr(1);
+        if (btrfs_item_size(eb, item) != strlen(split2)) {
+                test_msg("Invalid len in the second split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        read_extent_buffer(eb, buf, btrfs_item_ptr_offset(eb, 1),
+                           strlen(split2));
+        if (memcmp(buf, split2, strlen(split2))) {
+                test_msg("Data in the buffer doesn't match what it should "
+                         "in the second split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        key.offset = 1;
+        /* Do it again so we test memmoving the other items in the leaf */
+        ret = btrfs_split_item(NULL, root, path, &key, 4);
+        if (ret) {
+                test_msg("Second split item failed %d\n", ret);
+                goto out;
+        }
+        btrfs_item_key_to_cpu(eb, &key, 0);
+        if (key.objectid != 0 || key.type != BTRFS_EXTENT_CSUM_KEY ||
+            key.offset != 0) {
+                test_msg("Invalid key at slot 0\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        item = btrfs_item_nr(0);
+        if (btrfs_item_size(eb, item) != strlen(split3)) {
+                test_msg("Invalid len in the first split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        read_extent_buffer(eb, buf, btrfs_item_ptr_offset(eb, 0),
+                           strlen(split3));
+        if (memcmp(buf, split3, strlen(split3))) {
+                test_msg("Data in the buffer doesn't match what it should "
+                         "in the third split");
+                ret = -EINVAL;
+                goto out;
+        }
+        btrfs_item_key_to_cpu(eb, &key, 1);
+        if (key.objectid != 0 || key.type != BTRFS_EXTENT_CSUM_KEY ||
+            key.offset != 1) {
+                test_msg("Invalid key at slot 1\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        item = btrfs_item_nr(1);
+        if (btrfs_item_size(eb, item) != strlen(split4)) {
+                test_msg("Invalid len in the second split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        read_extent_buffer(eb, buf, btrfs_item_ptr_offset(eb, 1),
+                           strlen(split4));
+        if (memcmp(buf, split4, strlen(split4))) {
+                test_msg("Data in the buffer doesn't match what it should "
+                         "in the fourth split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        btrfs_item_key_to_cpu(eb, &key, 2);
+        if (key.objectid != 0 || key.type != BTRFS_EXTENT_CSUM_KEY ||
+            key.offset != 3) {
+                test_msg("Invalid key at slot 2\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        item = btrfs_item_nr(2);
+        if (btrfs_item_size(eb, item) != strlen(split2)) {
+                test_msg("Invalid len in the second split\n");
+                ret = -EINVAL;
+                goto out;
+        }
+        read_extent_buffer(eb, buf, btrfs_item_ptr_offset(eb, 2),
+                           strlen(split2));
+        if (memcmp(buf, split2, strlen(split2))) {
+                test_msg("Data in the buffer doesn't match what it should "
+                         "in the last chunk\n");
+                ret = -EINVAL;
+                goto out;
+        }
+out:
+        btrfs_free_path(path);
+        kfree(root);
+        return ret;
+}
+int btrfs_test_extent_buffer_operations(void)
+{
+        test_msg("Running extent buffer operation tests");
+        return test_btrfs_split_item();
+}
diff --git a/fs/btrfs/tests/extent-io-tests.c b/fs/btrfs/tests/extent-io-tests.c
new file mode 100644
index 000000000000..7e99c2f98dd0
--- /dev/null
+++ b/fs/btrfs/tests/extent-io-tests.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2013 Fusion IO.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#include <linux/pagemap.h>
+#include <linux/sched.h>
+#include "btrfs-tests.h"
+#include "../extent_io.h"
+#define PROCESS_UNLOCK          (1 << 0)
+#define PROCESS_RELEASE         (1 << 1)
+#define PROCESS_TEST_LOCKED     (1 << 2)
+static noinline int process_page_range(struct inode *inode, u64 start, u64 end,
+                                       unsigned long flags)
+{
+        int ret;
+        struct page *pages[16];
+        unsigned long index = start >> PAGE_CACHE_SHIFT;
+        unsigned long end_index = end >> PAGE_CACHE_SHIFT;
+        unsigned long nr_pages = end_index - index + 1;
+        int i;
+        int count = 0;
+        int loops = 0;
+        while (nr_pages > 0) {
+                ret = find_get_pages_contig(inode->i_mapping, index,
+                                     min_t(unsigned long, nr_pages,
+                                     ARRAY_SIZE(pages)), pages);
+                for (i = 0; i < ret; i++) {
+                        if (flags & PROCESS_TEST_LOCKED &&
+                            !PageLocked(pages[i]))
+                                count++;
+                        if (flags & PROCESS_UNLOCK && PageLocked(pages[i]))
+                                unlock_page(pages[i]);
+                        page_cache_release(pages[i]);
+                        if (flags & PROCESS_RELEASE)
+                                page_cache_release(pages[i]);
+                }
+                nr_pages -= ret;
+                index += ret;
+                cond_resched();
+                loops++;
+                if (loops > 100000) {
+                        printk(KERN_ERR "stuck in a loop, start %Lu, end %Lu, nr_pages %lu, ret %d\n", start, end, nr_pages, ret);
+                        break;
+                }
+        }
+        return count;
+}
+static int test_find_delalloc(void)
+{
+        struct inode *inode;
+        struct extent_io_tree tmp;
+        struct page *page;
+        struct page *locked_page = NULL;
+        unsigned long index = 0;
+        u64 total_dirty = 256 * 1024 * 1024;
+        u64 max_bytes = 128 * 1024 * 1024;
+        u64 start, end, test_start;
+        u64 found;
+        int ret = -EINVAL;
+        inode = btrfs_new_test_inode();
+        if (!inode) {
+                test_msg("Failed to allocate test inode\n");
+                return -ENOMEM;
+        }
+        extent_io_tree_init(&tmp, &inode->i_data);
+        /*
+         * First go through and create and mark all of our pages dirty, we pin
+         * everything to make sure our pages don't get evicted and screw up our
+         * test.
+         */
+        for (index = 0; index < (total_dirty >> PAGE_CACHE_SHIFT); index++) {
+                page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
+                if (!page) {
+                        test_msg("Failed to allocate test page\n");
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                SetPageDirty(page);
+                if (index) {
+                        unlock_page(page);
+                } else {
+                        page_cache_get(page);
+                        locked_page = page;
+                }
+        }
+        /* Test this scenario
+         * |--- delalloc ---|
+         * |---  search  ---|
+         */
+        set_extent_delalloc(&tmp, 0, 4095, NULL, GFP_NOFS);
+        start = 0;
+        end = 0;
+        found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
+                                         &end, max_bytes);
+        if (!found) {
+                test_msg("Should have found at least one delalloc\n");
+                goto out_bits;
+        }
+        if (start != 0 || end != 4095) {
+                test_msg("Expected start 0 end 4095, got start %Lu end %Lu\n",
+                         start, end);
+                goto out_bits;
+        }
+        unlock_extent(&tmp, start, end);
+        unlock_page(locked_page);
+        page_cache_release(locked_page);
+        /*
+         * Test this scenario
+         *
+         * |--- delalloc ---|
+         *           |--- search ---|
+         */
+        test_start = 64 * 1024 * 1024;
+        locked_page = find_lock_page(inode->i_mapping,
+                                     test_start >> PAGE_CACHE_SHIFT);
+        if (!locked_page) {
+                test_msg("Couldn't find the locked page\n");
+                goto out_bits;
+        }
+        set_extent_delalloc(&tmp, 4096, max_bytes - 1, NULL, GFP_NOFS);
+        start = test_start;
+        end = 0;
+        found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
+                                         &end, max_bytes);
+        if (!found) {
+                test_msg("Couldn't find delalloc in our range\n");
+                goto out_bits;
+        }
+        if (start != test_start || end != max_bytes - 1) {
+                test_msg("Expected start %Lu end %Lu, got start %Lu, end "
+                         "%Lu\n", test_start, max_bytes - 1, start, end);
+                goto out_bits;
+        }
+        if (process_page_range(inode, start, end,
+                               PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) {
+                test_msg("There were unlocked pages in the range\n");
+                goto out_bits;
+        }
+        unlock_extent(&tmp, start, end);
+        /* locked_page was unlocked above */
+        page_cache_release(locked_page);
+        /*
+         * Test this scenario
+         * |--- delalloc ---|
+         *                    |--- search ---|
+         */
+        test_start = max_bytes + 4096;
+        locked_page = find_lock_page(inode->i_mapping, test_start >>
+                                     PAGE_CACHE_SHIFT);
+        if (!locked_page) {
+                test_msg("Could'nt find the locked page\n");
+                goto out_bits;
+        }
+        start = test_start;
+        end = 0;
+        found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
+                                         &end, max_bytes);
+        if (found) {
+                test_msg("Found range when we shouldn't have\n");
+                goto out_bits;
+        }
+        if (end != (u64)-1) {
+                test_msg("Did not return the proper end offset\n");
+                goto out_bits;
+        }
+        /*
+         * Test this scenario
+         * [------- delalloc -------|
+         * [max_bytes]|-- search--|
+         *
+         * We are re-using our test_start from above since it works out well.
+         */
+        set_extent_delalloc(&tmp, max_bytes, total_dirty - 1, NULL, GFP_NOFS);
+        start = test_start;
+        end = 0;
+        found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
+                                         &end, max_bytes);
+        if (!found) {
+                test_msg("Didn't find our range\n");
+                goto out_bits;
+        }
+        if (start != test_start || end != total_dirty - 1) {
+                test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n",
+                         test_start, total_dirty - 1, start, end);
+                goto out_bits;
+        }
+        if (process_page_range(inode, start, end,
+                               PROCESS_TEST_LOCKED | PROCESS_UNLOCK)) {
+                test_msg("Pages in range were not all locked\n");
+                goto out_bits;
+        }
+        unlock_extent(&tmp, start, end);
+        /*
+         * Now to test where we run into a page that is no longer dirty in the
+         * range we want to find.
+         */
+        page = find_get_page(inode->i_mapping, (max_bytes + (1 * 1024 * 1024))
+                             >> PAGE_CACHE_SHIFT);
+        if (!page) {
+                test_msg("Couldn't find our page\n");
+                goto out_bits;
+        }
+        ClearPageDirty(page);
+        page_cache_release(page);
+        /* We unlocked it in the previous test */
+        lock_page(locked_page);
+        start = test_start;
+        end = 0;
+        /*
+         * Currently if we fail to find dirty pages in the delalloc range we
+         * will adjust max_bytes down to PAGE_CACHE_SIZE and then re-search.  If
+         * this changes at any point in the future we will need to fix this
+         * tests expected behavior.
+         */
+        found = find_lock_delalloc_range(inode, &tmp, locked_page, &start,
+                                         &end, max_bytes);
+        if (!found) {
+                test_msg("Didn't find our range\n");
+                goto out_bits;
+        }
+        if (start != test_start && end != test_start + PAGE_CACHE_SIZE - 1) {
+                test_msg("Expected start %Lu end %Lu, got start %Lu end %Lu\n",
+                         test_start, test_start + PAGE_CACHE_SIZE - 1, start,
+                         end);
+                goto out_bits;
+        }
+        if (process_page_range(inode, start, end, PROCESS_TEST_LOCKED |
+                               PROCESS_UNLOCK)) {
+                test_msg("Pages in range were not all locked\n");
+                goto out_bits;
+        }
+        ret = 0;
+out_bits:
+        clear_extent_bits(&tmp, 0, total_dirty - 1,
+                          (unsigned long)-1, GFP_NOFS);
+out:
+        if (locked_page)
+                page_cache_release(locked_page);
+        process_page_range(inode, 0, total_dirty - 1,
+                           PROCESS_UNLOCK | PROCESS_RELEASE);
+        iput(inode);
+        return ret;
+}
+int btrfs_test_extent_io(void)
+{
+        test_msg("Running find delalloc tests\n");
+        return test_find_delalloc();
+}
diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
new file mode 100644
index 000000000000..397d1f99a8eb
--- /dev/null
+++ b/fs/btrfs/tests/inode-tests.c
@@ -0,0 +1,955 @@
+/*
+ * Copyright (C) 2013 Fusion IO.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License v2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 021110-1307, USA.
+ */
+#include "btrfs-tests.h"
+#include "../ctree.h"
+#include "../btrfs_inode.h"
+#include "../disk-io.h"
+#include "../extent_io.h"
+#include "../volumes.h"
+static struct btrfs_fs_info *alloc_dummy_fs_info(void)
+{
+        struct btrfs_fs_info *fs_info = kzalloc(sizeof(struct btrfs_fs_info),
+                                                GFP_NOFS);
+        if (!fs_info)
+                return fs_info;
+        fs_info->fs_devices = kzalloc(sizeof(struct btrfs_fs_devices),
+                                      GFP_NOFS);
+        if (!fs_info->fs_devices) {
+                kfree(fs_info);
+                return NULL;
+        }
+        return fs_info;
+}
+static void free_dummy_root(struct btrfs_root *root)
+{
+        if (!root)
+                return;
+        if (root->fs_info) {
+                kfree(root->fs_info->fs_devices);
+                kfree(root->fs_info);
+        }
+        if (root->node)
+                free_extent_buffer(root->node);
+        kfree(root);
+}
+static void insert_extent(struct btrfs_root *root, u64 start, u64 len,
+                          u64 ram_bytes, u64 offset, u64 disk_bytenr,
+                          u64 disk_len, u32 type, u8 compression, int slot)
+{
+        struct btrfs_path path;
+        struct btrfs_file_extent_item *fi;
+        struct extent_buffer *leaf = root->node;
+        struct btrfs_key key;
+        u32 value_len = sizeof(struct btrfs_file_extent_item);
+        if (type == BTRFS_FILE_EXTENT_INLINE)
+                value_len += len;
+        memset(&path, 0, sizeof(path));
+        path.nodes[0] = leaf;
+        path.slots[0] = slot;
+        key.objectid = BTRFS_FIRST_FREE_OBJECTID;
+        key.type = BTRFS_EXTENT_DATA_KEY;
+        key.offset = start;
+        setup_items_for_insert(root, &path, &key, &value_len, value_len,
+                               value_len + sizeof(struct btrfs_item), 1);
+        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+        btrfs_set_file_extent_generation(leaf, fi, 1);
+        btrfs_set_file_extent_type(leaf, fi, type);
+        btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
+        btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_len);
+        btrfs_set_file_extent_offset(leaf, fi, offset);
+        btrfs_set_file_extent_num_bytes(leaf, fi, len);
+        btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
+        btrfs_set_file_extent_compression(leaf, fi, compression);
+        btrfs_set_file_extent_encryption(leaf, fi, 0);
+        btrfs_set_file_extent_other_encoding(leaf, fi, 0);
+}
+static void insert_inode_item_key(struct btrfs_root *root)
+{
+        struct btrfs_path path;
+        struct extent_buffer *leaf = root->node;
+        struct btrfs_key key;
+        u32 value_len = 0;
+        memset(&path, 0, sizeof(path));
+        path.nodes[0] = leaf;
+        path.slots[0] = 0;
+        key.objectid = BTRFS_INODE_ITEM_KEY;
+        key.type = BTRFS_INODE_ITEM_KEY;
+        key.offset = 0;
+        setup_items_for_insert(root, &path, &key, &value_len, value_len,
+                               value_len + sizeof(struct btrfs_item), 1);
+}
+/*
+ * Build the most complicated map of extents the earth has ever seen.  We want
+ * this so we can test all of the corner cases of btrfs_get_extent.  Here is a
+ * diagram of how the extents will look though this may not be possible we still
+ * want to make sure everything acts normally (the last number is not inclusive)
+ *
+ * [0 - 5][5 -  6][6 - 10][10 - 4096][  4096 - 8192 ][8192 - 12288]
+ * [hole ][inline][ hole ][ regular ][regular1 split][    hole    ]
+ *
+ * [ 12288 - 20480][20480 - 24576][  24576 - 28672  ][28672 - 36864][36864 - 45056]
+ * [regular1 split][   prealloc1 ][prealloc1 written][   prealloc1 ][ compressed  ]
+ *
+ * [45056 - 49152][49152-53248][53248-61440][61440-65536][     65536+81920   ]
+ * [ compressed1 ][  regular  ][compressed1][  regular  ][ hole but no extent]
+ *
+ * [81920-86016]
+ * [  regular  ]
+ */
+static void setup_file_extents(struct btrfs_root *root)
+{
+        int slot = 0;
+        u64 disk_bytenr = 1 * 1024 * 1024;
+        u64 offset = 0;
+        /* First we want a hole */
+        insert_extent(root, offset, 5, 5, 0, 0, 0, BTRFS_FILE_EXTENT_REG, 0,
+                      slot);
+        slot++;
+        offset += 5;
+        /*
+         * Now we want an inline extent, I don't think this is possible but hey
+         * why not?  Also keep in mind if we have an inline extent it counts as
+         * the whole first page.  If we were to expand it we would have to cow
+         * and we wouldn't have an inline extent anymore.
+         */
+        insert_extent(root, offset, 1, 1, 0, 0, 0, BTRFS_FILE_EXTENT_INLINE, 0,
+                      slot);
+        slot++;
+        offset = 4096;
+        /* Now another hole */
+        insert_extent(root, offset, 4, 4, 0, 0, 0, BTRFS_FILE_EXTENT_REG, 0,
+                      slot);
+        slot++;
+        offset += 4;
+        /* Now for a regular extent */
+        insert_extent(root, offset, 4095, 4095, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        disk_bytenr += 4096;
+        offset += 4095;
+        /*
+         * Now for 3 extents that were split from a hole punch so we test
+         * offsets properly.
+         */
+        insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 16384,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 4096, 4096, 0, 0, 0, BTRFS_FILE_EXTENT_REG,
+                      0, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 16384,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        offset += 8192;
+        disk_bytenr += 16384;
+        /* Now for a unwritten prealloc extent */
+        insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
+        slot++;
+        offset += 4096;
+        /*
+         * We want to jack up disk_bytenr a little more so the em stuff doesn't
+         * merge our records.
+         */
+        disk_bytenr += 8192;
+        /*
+         * Now for a partially written prealloc extent, basically the same as
+         * the hole punch example above.  Ram_bytes never changes when you mark
+         * extents written btw.
+         */
+        insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 16384,
+                      BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 4096, 16384, 4096, disk_bytenr, 16384,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 16384,
+                      BTRFS_FILE_EXTENT_PREALLOC, 0, slot);
+        slot++;
+        offset += 8192;
+        disk_bytenr += 16384;
+        /* Now a normal compressed extent */
+        insert_extent(root, offset, 8192, 8192, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
+        slot++;
+        offset += 8192;
+        /* No merges */
+        disk_bytenr += 8192;
+        /* Now a split compressed extent */
+        insert_extent(root, offset, 4096, 16384, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 4096, 4096, 0, disk_bytenr + 4096, 4096,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        offset += 4096;
+        insert_extent(root, offset, 8192, 16384, 8192, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, BTRFS_COMPRESS_ZLIB, slot);
+        slot++;
+        offset += 8192;
+        disk_bytenr += 8192;
+        /* Now extents that have a hole but no hole extent */
+        insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+        slot++;
+        offset += 16384;
+        disk_bytenr += 4096;
+        insert_extent(root, offset, 4096, 4096, 0, disk_bytenr, 4096,
+                      BTRFS_FILE_EXTENT_REG, 0, slot);
+}
+static unsigned long prealloc_only = 0;
+static unsigned long compressed_only = 0;
+static unsigned long vacancy_only = 0;
+static noinline int test_btrfs_get_extent(void)
+{
+        struct inode *inode = NULL;
+        struct btrfs_root *root = NULL;
+        struct extent_map *em = NULL;
+        u64 orig_start;
+        u64 disk_bytenr;
+        u64 offset;
+        int ret = -ENOMEM;
+        inode = btrfs_new_test_inode();
+        if (!inode) {
+                test_msg("Couldn't allocate inode\n");
+                return ret;
+        }
+        BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
+        BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
+        BTRFS_I(inode)->location.offset = 0;
+        root = btrfs_alloc_dummy_root();
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
+                goto out;
+        }
+        /*
+         * We do this since btrfs_get_extent wants to assign em->bdev to
+         * root->fs_info->fs_devices->latest_bdev.
+         */
+        root->fs_info = alloc_dummy_fs_info();
+        if (!root->fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
+                goto out;
+        }
+        root->node = alloc_dummy_extent_buffer(0, 4096);
+        if (!root->node) {
+                test_msg("Couldn't allocate dummy buffer\n");
+                goto out;
+        }
+        /*
+         * We will just free a dummy node if it's ref count is 2 so we need an
+         * extra ref so our searches don't accidently release our page.
+         */
+        extent_buffer_get(root->node);
+        btrfs_set_header_nritems(root->node, 0);
+        btrfs_set_header_level(root->node, 0);
+        ret = -EINVAL;
+        /* First with no extents */
+        BTRFS_I(inode)->root = root;
+        em = btrfs_get_extent(inode, NULL, 0, 0, 4096, 0);
+        if (IS_ERR(em)) {
+                em = NULL;
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (!test_bit(EXTENT_FLAG_VACANCY, &em->flags)) {
+                test_msg("Vacancy flag wasn't set properly\n");
+                goto out;
+        }
+        free_extent_map(em);
+        btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
+        /*
+         * All of the magic numbers are based on the mapping setup in
+         * setup_file_extents, so if you change anything there you need to
+         * update the comment and update the expected values below.
+         */
+        setup_file_extents(root);
+        em = btrfs_get_extent(inode, NULL, 0, 0, (u64)-1, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != 0 || em->len != 5) {
+                test_msg("Unexpected extent wanted start 0 len 5, got start "
+                         "%llu len %llu\n", em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_INLINE) {
+                test_msg("Expected an inline, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4091) {
+                test_msg("Unexpected extent wanted start %llu len 1, got start "
+                         "%llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        /*
+         * We don't test anything else for inline since it doesn't get set
+         * unless we have a page for it to write into.  Maybe we should change
+         * this?
+         */
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4) {
+                test_msg("Unexpected extent wanted start %llu len 4, got start "
+                         "%llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* Regular extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4095) {
+                test_msg("Unexpected extent wanted start %llu len 4095, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* The next 3 are split extents */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        disk_bytenr = em->block_start;
+        orig_start = em->start;
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 8192) {
+                test_msg("Unexpected extent wanted start %llu len 8192, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != orig_start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n",
+                         orig_start, em->orig_start);
+                goto out;
+        }
+        disk_bytenr += (em->start - orig_start);
+        if (em->block_start != disk_bytenr) {
+                test_msg("Wrong block start, want %llu, have %llu\n",
+                         disk_bytenr, em->block_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* Prealloc extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != prealloc_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         prealloc_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* The next 3 are a half written prealloc extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != prealloc_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         prealloc_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        disk_bytenr = em->block_start;
+        orig_start = em->start;
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_HOLE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != orig_start) {
+                test_msg("Unexpected orig offset, wanted %llu, have %llu\n",
+                         orig_start, em->orig_start);
+                goto out;
+        }
+        if (em->block_start != (disk_bytenr + (em->start - em->orig_start))) {
+                test_msg("Unexpected block start, wanted %llu, have %llu\n",
+                         disk_bytenr + (em->start - em->orig_start),
+                         em->block_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 8192) {
+                test_msg("Unexpected extent wanted start %llu len 8192, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != prealloc_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         prealloc_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != orig_start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", orig_start,
+                         em->orig_start);
+                goto out;
+        }
+        if (em->block_start != (disk_bytenr + (em->start - em->orig_start))) {
+                test_msg("Unexpected block start, wanted %llu, have %llu\n",
+                         disk_bytenr + (em->start - em->orig_start),
+                         em->block_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* Now for the compressed extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 8192) {
+                test_msg("Unexpected extent wanted start %llu len 8192, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != compressed_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         compressed_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n",
+                         em->start, em->orig_start);
+                goto out;
+        }
+        if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
+                test_msg("Unexpected compress type, wanted %d, got %d\n",
+                         BTRFS_COMPRESS_ZLIB, em->compress_type);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* Split compressed extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != compressed_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         compressed_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n",
+                         em->start, em->orig_start);
+                goto out;
+        }
+        if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
+                test_msg("Unexpected compress type, wanted %d, got %d\n",
+                         BTRFS_COMPRESS_ZLIB, em->compress_type);
+                goto out;
+        }
+        disk_bytenr = em->block_start;
+        orig_start = em->start;
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != disk_bytenr) {
+                test_msg("Block start does not match, want %llu got %llu\n",
+                         disk_bytenr, em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 8192) {
+                test_msg("Unexpected extent wanted start %llu len 8192, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != compressed_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         compressed_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != orig_start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n",
+                         em->start, orig_start);
+                goto out;
+        }
+        if (em->compress_type != BTRFS_COMPRESS_ZLIB) {
+                test_msg("Unexpected compress type, wanted %d, got %d\n",
+                         BTRFS_COMPRESS_ZLIB, em->compress_type);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        /* A hole between regular extents but no hole extent */
+        em = btrfs_get_extent(inode, NULL, 0, offset + 6, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096 * 1024, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        /*
+         * Currently we just return a length that we requested rather than the
+         * length of the actual hole, if this changes we'll have to change this
+         * test.
+         */
+        if (em->start != offset || em->len != 12288) {
+                test_msg("Unexpected extent wanted start %llu len 12288, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != vacancy_only) {
+                test_msg("Unexpected flags set, want %lu have %lu\n",
+                         vacancy_only, em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        offset = em->start + em->len;
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, offset, 4096, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != offset || em->len != 4096) {
+                test_msg("Unexpected extent wanted start %llu len 4096, got "
+                         "start %llu len %llu\n", offset, em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, want 0 have %lu\n", em->flags);
+                goto out;
+        }
+        if (em->orig_start != em->start) {
+                test_msg("Wrong orig offset, want %llu, have %llu\n", em->start,
+                         em->orig_start);
+                goto out;
+        }
+        ret = 0;
+out:
+        if (!IS_ERR(em))
+                free_extent_map(em);
+        iput(inode);
+        free_dummy_root(root);
+        return ret;
+}
+static int test_hole_first(void)
+{
+        struct inode *inode = NULL;
+        struct btrfs_root *root = NULL;
+        struct extent_map *em = NULL;
+        int ret = -ENOMEM;
+        inode = btrfs_new_test_inode();
+        if (!inode) {
+                test_msg("Couldn't allocate inode\n");
+                return ret;
+        }
+        BTRFS_I(inode)->location.type = BTRFS_INODE_ITEM_KEY;
+        BTRFS_I(inode)->location.objectid = BTRFS_FIRST_FREE_OBJECTID;
+        BTRFS_I(inode)->location.offset = 0;
+        root = btrfs_alloc_dummy_root();
+        if (IS_ERR(root)) {
+                test_msg("Couldn't allocate root\n");
+                goto out;
+        }
+        root->fs_info = alloc_dummy_fs_info();
+        if (!root->fs_info) {
+                test_msg("Couldn't allocate dummy fs info\n");
+                goto out;
+        }
+        root->node = alloc_dummy_extent_buffer(0, 4096);
+        if (!root->node) {
+                test_msg("Couldn't allocate dummy buffer\n");
+                goto out;
+        }
+        extent_buffer_get(root->node);
+        btrfs_set_header_nritems(root->node, 0);
+        btrfs_set_header_level(root->node, 0);
+        BTRFS_I(inode)->root = root;
+        ret = -EINVAL;
+        /*
+         * Need a blank inode item here just so we don't confuse
+         * btrfs_get_extent.
+         */
+        insert_inode_item_key(root);
+        insert_extent(root, 4096, 4096, 4096, 0, 4096, 4096,
+                      BTRFS_FILE_EXTENT_REG, 0, 1);
+        em = btrfs_get_extent(inode, NULL, 0, 0, 8192, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != EXTENT_MAP_HOLE) {
+                test_msg("Expected a hole, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != 0 || em->len != 4096) {
+                test_msg("Unexpected extent wanted start 0 len 4096, got start "
+                         "%llu len %llu\n", em->start, em->len);
+                goto out;
+        }
+        if (em->flags != vacancy_only) {
+                test_msg("Wrong flags, wanted %lu, have %lu\n", vacancy_only,
+                         em->flags);
+                goto out;
+        }
+        free_extent_map(em);
+        em = btrfs_get_extent(inode, NULL, 0, 4096, 8192, 0);
+        if (IS_ERR(em)) {
+                test_msg("Got an error when we shouldn't have\n");
+                goto out;
+        }
+        if (em->block_start != 4096) {
+                test_msg("Expected a real extent, got %llu\n", em->block_start);
+                goto out;
+        }
+        if (em->start != 4096 || em->len != 4096) {
+                test_msg("Unexpected extent wanted start 4096 len 4096, got "
+                         "start %llu len %llu\n", em->start, em->len);
+                goto out;
+        }
+        if (em->flags != 0) {
+                test_msg("Unexpected flags set, wanted 0 got %lu\n",
+                         em->flags);
+                goto out;
+        }
+        ret = 0;
+out:
+        if (!IS_ERR(em))
+                free_extent_map(em);
+        iput(inode);
+        free_dummy_root(root);
+        return ret;
+}
+int btrfs_test_inodes(void)
+{
+        int ret;
+        set_bit(EXTENT_FLAG_COMPRESSED, &compressed_only);
+        set_bit(EXTENT_FLAG_VACANCY, &vacancy_only);
+        set_bit(EXTENT_FLAG_PREALLOC, &prealloc_only);
+        test_msg("Running btrfs_get_extent tests\n");
+        ret = test_btrfs_get_extent();
+        if (ret)
+                return ret;
+        test_msg("Running hole first btrfs_get_extent test\n");
+        return test_hole_first();
+}
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index cac4a3f76323..c6a872a8a468 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -57,7 +57,7 @@ static unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
                                           __TRANS_JOIN_NOLOCK),
 };
-static void put_transaction(struct btrfs_transaction *transaction)
+void btrfs_put_transaction(struct btrfs_transaction *transaction)
 {
        WARN_ON(atomic_read(&transaction->use_count) == 0);
        if (atomic_dec_and_test(&transaction->use_count)) {
@@ -332,7 +332,7 @@ static void wait_current_trans(struct btrfs_root *root)
                wait_event(root->fs_info->transaction_wait,
                           cur_trans->state >= TRANS_STATE_UNBLOCKED ||
                           cur_trans->aborted);
-                put_transaction(cur_trans);
+                btrfs_put_transaction(cur_trans);
        } else {
                spin_unlock(&root->fs_info->trans_lock);
        }
@@ -353,6 +353,17 @@ static int may_wait_transaction(struct btrfs_root *root, int type)
        return 0;
 }
+static inline bool need_reserve_reloc_root(struct btrfs_root *root)
+{
+        if (!root->fs_info->reloc_ctl ||
+            !root->ref_cows ||
+            root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
+            root->reloc_root)
+                return false;
+        return true;
+}
 static struct btrfs_trans_handle *
 start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
                  enum btrfs_reserve_flush_enum flush)
@@ -360,8 +371,9 @@ start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
        struct btrfs_trans_handle *h;
        struct btrfs_transaction *cur_trans;
        u64 num_bytes = 0;
-        int ret;
        u64 qgroup_reserved = 0;
+        bool reloc_reserved = false;
+        int ret;
        if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
                return ERR_PTR(-EROFS);
@@ -390,6 +402,14 @@ start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
                }
                num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
+                /*
+                 * Do the reservation for the relocation root creation
+                 */
+                if (unlikely(need_reserve_reloc_root(root))) {
+                        num_bytes += root->nodesize;
+                        reloc_reserved = true;
+                }
                ret = btrfs_block_rsv_add(root,
                                          &root->fs_info->trans_block_rsv,
                                          num_bytes, flush);
@@ -451,6 +471,7 @@ again:
        h->delayed_ref_elem.seq = 0;
        h->type = type;
        h->allocating_chunk = false;
+        h->reloc_reserved = false;
        INIT_LIST_HEAD(&h->qgroup_ref_list);
        INIT_LIST_HEAD(&h->new_bgs);
@@ -466,6 +487,7 @@ again:
                                              h->transid, num_bytes, 1);
                h->block_rsv = &root->fs_info->trans_block_rsv;
                h->bytes_reserved = num_bytes;
+                h->reloc_reserved = reloc_reserved;
        }
        h->qgroup_reserved = qgroup_reserved;
@@ -610,7 +632,7 @@ int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
        }
        wait_for_commit(root, cur_trans);
-        put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
 out:
        return ret;
 }
@@ -735,7 +757,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
        smp_mb();
        if (waitqueue_active(&cur_trans->writer_wait))
                wake_up(&cur_trans->writer_wait);
-        put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
        if (current->journal_info == trans)
                current->journal_info = NULL;
@@ -744,8 +766,10 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
                btrfs_run_delayed_iputs(root);
        if (trans->aborted ||
-            test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
+            test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
+                wake_up_process(info->transaction_kthread);
                err = -EIO;
+        }
        assert_qgroups_uptodate(trans);
        kmem_cache_free(btrfs_trans_handle_cachep, trans);
@@ -948,16 +972,19 @@ static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
                return ret;
        ret = btrfs_run_dev_stats(trans, root->fs_info);
-        WARN_ON(ret);
+        if (ret)
+                return ret;
        ret = btrfs_run_dev_replace(trans, root->fs_info);
-        WARN_ON(ret);
+        if (ret)
+                return ret;
        ret = btrfs_run_qgroups(trans, root->fs_info);
-        BUG_ON(ret);
+        if (ret)
+                return ret;
        /* run_qgroups might have added some more refs */
        ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
-        BUG_ON(ret);
+        if (ret)
+                return ret;
        while (!list_empty(&fs_info->dirty_cowonly_roots)) {
                next = fs_info->dirty_cowonly_roots.next;
@@ -1453,7 +1480,7 @@ static void do_async_commit(struct work_struct *work)
         * We've got freeze protection passed with the transaction.
         * Tell lockdep about it.
         */
-        if (ac->newtrans->type < TRANS_JOIN_NOLOCK)
+        if (ac->newtrans->type & __TRANS_FREEZABLE)
                rwsem_acquire_read(
                     &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
                     0, 1, _THIS_IP_);
@@ -1494,7 +1521,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
         * Tell lockdep we've released the freeze rwsem, since the
         * async commit thread will be the one to unlock it.
         */
-        if (trans->type < TRANS_JOIN_NOLOCK)
+        if (ac->newtrans->type & __TRANS_FREEZABLE)
                rwsem_release(
                        &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
                        1, _THIS_IP_);
@@ -1510,7 +1537,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
        if (current->journal_info == trans)
                current->journal_info = NULL;
-        put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
        return 0;
 }
@@ -1552,8 +1579,10 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans,
                root->fs_info->running_transaction = NULL;
        spin_unlock(&root->fs_info->trans_lock);
-        put_transaction(cur_trans);
+        if (trans->type & __TRANS_FREEZABLE)
-        put_transaction(cur_trans);
+                sb_end_intwrite(root->fs_info->sb);
+        btrfs_put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
        trace_btrfs_transaction_commit(root);
@@ -1571,15 +1600,19 @@ static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
        int ret;
        ret = btrfs_run_delayed_items(trans, root);
-        if (ret)
-                return ret;
        /*
         * running the delayed items may have added new refs. account
         * them now so that they hinder processing of more delayed refs
         * as little as possible.
         */
-        btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
+        if (ret) {
+                btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
+                return ret;
+        }
+        ret = btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
+        if (ret)
+                return ret;
        /*
         * rename don't use btrfs_join_transaction, so, once we
@@ -1596,14 +1629,14 @@ static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
 static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
 {
        if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
-                return btrfs_start_all_delalloc_inodes(fs_info, 1);
+                return btrfs_start_delalloc_roots(fs_info, 1);
        return 0;
 }
 static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
 {
        if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
-                btrfs_wait_all_ordered_extents(fs_info, 1);
+                btrfs_wait_ordered_roots(fs_info, -1);
 }
 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
@@ -1669,7 +1702,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
                wait_for_commit(root, cur_trans);
-                put_transaction(cur_trans);
+                btrfs_put_transaction(cur_trans);
                return ret;
        }
@@ -1686,7 +1719,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
                        wait_for_commit(root, prev_trans);
-                        put_transaction(prev_trans);
+                        btrfs_put_transaction(prev_trans);
                } else {
                        spin_unlock(&root->fs_info->trans_lock);
                }
@@ -1838,11 +1871,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        assert_qgroups_uptodate(trans);
        update_super_roots(root);
-        if (!root->fs_info->log_root_recovering) {
+        btrfs_set_super_log_root(root->fs_info->super_copy, 0);
-                btrfs_set_super_log_root(root->fs_info->super_copy, 0);
+        btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
-                btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
-        }
        memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
               sizeof(*root->fs_info->super_copy));
@@ -1888,8 +1918,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        list_del_init(&cur_trans->list);
        spin_unlock(&root->fs_info->trans_lock);
-        put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
-        put_transaction(cur_trans);
+        btrfs_put_transaction(cur_trans);
        if (trans->type & __TRANS_FREEZABLE)
                sb_end_intwrite(root->fs_info->sb);
diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 5c2af8491621..7657d115067d 100644
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -92,6 +92,7 @@ struct btrfs_trans_handle {
        short aborted;
        short adding_csums;
        bool allocating_chunk;
+        bool reloc_reserved;
        unsigned int type;
        /*
         * this root is only needed to validate that the root passed to
@@ -166,4 +167,5 @@ int btrfs_wait_marked_extents(struct btrfs_root *root,
                                struct extent_io_tree *dirty_pages, int mark);
 int btrfs_transaction_blocked(struct btrfs_fs_info *info);
 int btrfs_transaction_in_commit(struct btrfs_fs_info *info);
+void btrfs_put_transaction(struct btrfs_transaction *transaction);
 #endif
diff --git a/fs/btrfs/tree-defrag.c b/fs/btrfs/tree-defrag.c
index 94e05c1f118a..76928ca97741 100644
--- a/fs/btrfs/tree-defrag.c
+++ b/fs/btrfs/tree-defrag.c
@@ -37,7 +37,6 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
        int ret = 0;
        int wret;
        int level;
-        int is_extent = 0;
        int next_key_ret = 0;
        u64 last_ret = 0;
        u64 min_trans = 0;
@@ -50,7 +49,7 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
                goto out;
        }
-        if (root->ref_cows == 0 && !is_extent)
+        if (root->ref_cows == 0)
                goto out;
        if (btrfs_test_opt(root, SSD))
@@ -85,7 +84,7 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
        path->keep_locks = 1;
-        ret = btrfs_search_forward(root, &key, NULL, path, min_trans);
+        ret = btrfs_search_forward(root, &key, path, min_trans);
        if (ret < 0)
                goto out;
        if (ret > 0) {
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 0d9613c3f5e5..9f7fc51ca334 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -26,7 +26,6 @@
 #include "locking.h"
 #include "print-tree.h"
 #include "backref.h"
-#include "compat.h"
 #include "tree-log.h"
 #include "hash.h"
@@ -93,7 +92,8 @@
 */
 #define LOG_WALK_PIN_ONLY 0
 #define LOG_WALK_REPLAY_INODES 1
-#define LOG_WALK_REPLAY_ALL 2
+#define LOG_WALK_REPLAY_DIR_INDEX 2
+#define LOG_WALK_REPLAY_ALL 3
 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root, struct inode *inode,
@@ -393,6 +393,7 @@ static noinline int overwrite_item(struct btrfs_trans_handle *trans,
                if (inode_item) {
                        struct btrfs_inode_item *item;
                        u64 nbytes;
+                        u32 mode;
                        item = btrfs_item_ptr(path->nodes[0], path->slots[0],
                                              struct btrfs_inode_item);
@@ -400,9 +401,19 @@ static noinline int overwrite_item(struct btrfs_trans_handle *trans,
                        item = btrfs_item_ptr(eb, slot,
                                              struct btrfs_inode_item);
                        btrfs_set_inode_nbytes(eb, item, nbytes);
+                        /*
+                         * If this is a directory we need to reset the i_size to
+                         * 0 so that we can set it up properly when replaying
+                         * the rest of the items in this log.
+                         */
+                        mode = btrfs_inode_mode(eb, item);
+                        if (S_ISDIR(mode))
+                                btrfs_set_inode_size(eb, item, 0);
                }
        } else if (inode_item) {
                struct btrfs_inode_item *item;
+                u32 mode;
                /*
                 * New inode, set nbytes to 0 so that the nbytes comes out
@@ -410,6 +421,15 @@ static noinline int overwrite_item(struct btrfs_trans_handle *trans,
                 */
                item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
                btrfs_set_inode_nbytes(eb, item, 0);
+                /*
+                 * If this is a directory we need to reset the i_size to 0 so
+                 * that we can set it up properly when replaying the rest of
+                 * the items in this log.
+                 */
+                mode = btrfs_inode_mode(eb, item);
+                if (S_ISDIR(mode))
+                        btrfs_set_inode_size(eb, item, 0);
        }
 insert:
        btrfs_release_path(path);
@@ -915,7 +935,7 @@ again:
                                            parent_objectid,
                                            victim_name,
                                            victim_name_len)) {
-                                btrfs_inc_nlink(inode);
+                                inc_nlink(inode);
                                btrfs_release_path(path);
                                ret = btrfs_unlink_inode(trans, root, dir,
@@ -985,7 +1005,7 @@ again:
                                victim_parent = read_one_inode(root,
                                                               parent_objectid);
                                if (victim_parent) {
-                                        btrfs_inc_nlink(inode);
+                                        inc_nlink(inode);
                                        btrfs_release_path(path);
                                        ret = btrfs_unlink_inode(trans, root,
@@ -1092,11 +1112,11 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
                                  struct extent_buffer *eb, int slot,
                                  struct btrfs_key *key)
 {
-        struct inode *dir;
+        struct inode *dir = NULL;
-        struct inode *inode;
+        struct inode *inode = NULL;
        unsigned long ref_ptr;
        unsigned long ref_end;
-        char *name;
+        char *name = NULL;
        int namelen;
        int ret;
        int search_done = 0;
@@ -1129,13 +1149,15 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
         * care of the rest
         */
        dir = read_one_inode(root, parent_objectid);
-        if (!dir)
+        if (!dir) {
-                return -ENOENT;
+                ret = -ENOENT;
+                goto out;
+        }
        inode = read_one_inode(root, inode_objectid);
        if (!inode) {
-                iput(dir);
+                ret = -EIO;
-                return -EIO;
+                goto out;
        }
        while (ref_ptr < ref_end) {
@@ -1148,14 +1170,16 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
                         */
                        if (!dir)
                                dir = read_one_inode(root, parent_objectid);
-                        if (!dir)
+                        if (!dir) {
-                                return -ENOENT;
+                                ret = -ENOENT;
+                                goto out;
+                        }
                } else {
                        ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
                                             &ref_index);
                }
                if (ret)
-                        return ret;
+                        goto out;
                /* if we already have a perfect match, we're done */
                if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
@@ -1175,12 +1199,11 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
                                                      parent_objectid,
                                                      ref_index, name, namelen,
                                                      &search_done);
-                                if (ret == 1) {
+                                if (ret) {
-                                        ret = 0;
+                                        if (ret == 1)
+                                                ret = 0;
                                        goto out;
                                }
-                                if (ret)
-                                        goto out;
                        }
                        /* insert our name */
@@ -1194,6 +1217,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
                ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
                kfree(name);
+                name = NULL;
                if (log_ref_ver) {
                        iput(dir);
                        dir = NULL;
@@ -1204,6 +1228,7 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
        ret = overwrite_item(trans, root, path, eb, slot, key);
 out:
        btrfs_release_path(path);
+        kfree(name);
        iput(dir);
        iput(inode);
        return ret;
@@ -1286,6 +1311,7 @@ static int count_inode_refs(struct btrfs_root *root,
                                break;
                        path->slots[0]--;
                }
+process_slot:
                btrfs_item_key_to_cpu(path->nodes[0], &key,
                                      path->slots[0]);
                if (key.objectid != ino ||
@@ -1306,6 +1332,10 @@ static int count_inode_refs(struct btrfs_root *root,
                if (key.offset == 0)
                        break;
+                if (path->slots[0] > 0) {
+                        path->slots[0]--;
+                        goto process_slot;
+                }
                key.offset--;
                btrfs_release_path(path);
        }
@@ -1459,7 +1489,7 @@ static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
                if (!inode->i_nlink)
                        set_nlink(inode, 1);
                else
-                        btrfs_inc_nlink(inode);
+                        inc_nlink(inode);
                ret = btrfs_update_inode(trans, root, inode);
        } else if (ret == -EEXIST) {
                ret = 0;
@@ -1496,6 +1526,7 @@ static noinline int insert_one_name(struct btrfs_trans_handle *trans,
                iput(inode);
                return -EIO;
        }
        ret = btrfs_add_link(trans, dir, inode, name, name_len, 1, index);
        /* FIXME, put inode into FIXUP list */
@@ -1534,6 +1565,7 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans,
        u8 log_type;
        int exists;
        int ret = 0;
+        bool update_size = (key->type == BTRFS_DIR_INDEX_KEY);
        dir = read_one_inode(root, key->objectid);
        if (!dir)
@@ -1604,6 +1636,10 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans,
                goto insert;
 out:
        btrfs_release_path(path);
+        if (!ret && update_size) {
+                btrfs_i_size_write(dir, dir->i_size + name_len * 2);
+                ret = btrfs_update_inode(trans, root, dir);
+        }
        kfree(name);
        iput(dir);
        return ret;
@@ -1614,6 +1650,7 @@ insert:
                              name, name_len, log_type, &log_key);
        if (ret && ret != -ENOENT)
                goto out;
+        update_size = false;
        ret = 0;
        goto out;
 }
@@ -1795,7 +1832,7 @@ again:
                                                     dir_key->offset,
                                                     name, name_len, 0);
                }
-                if (IS_ERR_OR_NULL(log_di)) {
+                if (!log_di || (IS_ERR(log_di) && PTR_ERR(log_di) == -ENOENT)) {
                        btrfs_dir_item_key_to_cpu(eb, di, &location);
                        btrfs_release_path(path);
                        btrfs_release_path(log_path);
@@ -1813,7 +1850,7 @@ again:
                                goto out;
                        }
-                        btrfs_inc_nlink(inode);
+                        inc_nlink(inode);
                        ret = btrfs_unlink_inode(trans, root, dir, inode,
                                                 name, name_len);
                        if (!ret)
@@ -1832,6 +1869,9 @@ again:
                                goto again;
                        ret = 0;
                        goto out;
+                } else if (IS_ERR(log_di)) {
+                        kfree(name);
+                        return PTR_ERR(log_di);
                }
                btrfs_release_path(log_path);
                kfree(name);
@@ -2027,6 +2067,15 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                        if (ret)
                                break;
                }
+                if (key.type == BTRFS_DIR_INDEX_KEY &&
+                    wc->stage == LOG_WALK_REPLAY_DIR_INDEX) {
+                        ret = replay_one_dir_item(wc->trans, root, path,
+                                                  eb, i, &key);
+                        if (ret)
+                                break;
+                }
                if (wc->stage < LOG_WALK_REPLAY_ALL)
                        continue;
@@ -2048,8 +2097,7 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                                                eb, i, &key);
                        if (ret)
                                break;
-                } else if (key.type == BTRFS_DIR_ITEM_KEY ||
+                } else if (key.type == BTRFS_DIR_ITEM_KEY) {
-                           key.type == BTRFS_DIR_INDEX_KEY) {
                        ret = replay_one_dir_item(wc->trans, root, path,
                                                  eb, i, &key);
                        if (ret)
@@ -2082,8 +2130,7 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
                WARN_ON(*level >= BTRFS_MAX_LEVEL);
                cur = path->nodes[*level];
-                if (btrfs_header_level(cur) != *level)
+                WARN_ON(btrfs_header_level(cur) != *level);
-                        WARN_ON(1);
                if (path->slots[*level] >=
                    btrfs_header_nritems(cur))
@@ -2115,11 +2162,13 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
                                        return ret;
                                }
-                                btrfs_tree_lock(next);
+                                if (trans) {
-                                btrfs_set_lock_blocking(next);
+                                        btrfs_tree_lock(next);
-                                clean_tree_block(trans, root, next);
+                                        btrfs_set_lock_blocking(next);
-                                btrfs_wait_tree_block_writeback(next);
+                                        clean_tree_block(trans, root, next);
-                                btrfs_tree_unlock(next);
+                                        btrfs_wait_tree_block_writeback(next);
+                                        btrfs_tree_unlock(next);
+                                }
                                WARN_ON(root_owner !=
                                        BTRFS_TREE_LOG_OBJECTID);
@@ -2191,11 +2240,13 @@ static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
                                next = path->nodes[*level];
-                                btrfs_tree_lock(next);
+                                if (trans) {
-                                btrfs_set_lock_blocking(next);
+                                        btrfs_tree_lock(next);
-                                clean_tree_block(trans, root, next);
+                                        btrfs_set_lock_blocking(next);
-                                btrfs_wait_tree_block_writeback(next);
+                                        clean_tree_block(trans, root, next);
-                                btrfs_tree_unlock(next);
+                                        btrfs_wait_tree_block_writeback(next);
+                                        btrfs_tree_unlock(next);
+                                }
                                WARN_ON(root_owner != BTRFS_TREE_LOG_OBJECTID);
                                ret = btrfs_free_and_pin_reserved_extent(root,
@@ -2265,11 +2316,13 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
                        next = path->nodes[orig_level];
-                        btrfs_tree_lock(next);
+                        if (trans) {
-                        btrfs_set_lock_blocking(next);
+                                btrfs_tree_lock(next);
-                        clean_tree_block(trans, log, next);
+                                btrfs_set_lock_blocking(next);
-                        btrfs_wait_tree_block_writeback(next);
+                                clean_tree_block(trans, log, next);
-                        btrfs_tree_unlock(next);
+                                btrfs_wait_tree_block_writeback(next);
+                                btrfs_tree_unlock(next);
+                        }
                        WARN_ON(log->root_key.objectid !=
                                BTRFS_TREE_LOG_OBJECTID);
@@ -2535,9 +2588,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         * the running transaction open, so a full commit can't hop
         * in and cause problems either.
         */
-        btrfs_scrub_pause_super(root);
        ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
-        btrfs_scrub_continue_super(root);
        if (ret) {
                btrfs_abort_transaction(trans, root, ret);
                goto out_wake_log_root;
@@ -2572,13 +2623,10 @@ static void free_log_tree(struct btrfs_trans_handle *trans,
                .process_func = process_one_buffer
        };
-        if (trans) {
+        ret = walk_log_tree(trans, log, &wc);
-                ret = walk_log_tree(trans, log, &wc);
+        /* I don't think this can happen but just in case */
+        if (ret)
-                /* I don't think this can happen but just in case */
+                btrfs_abort_transaction(trans, log, ret);
-                if (ret)
-                        btrfs_abort_transaction(trans, log, ret);
-        }
        while (1) {
                ret = find_first_extent_bit(&log->dirty_log_pages,
@@ -2831,7 +2879,6 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
                          u64 min_offset, u64 *last_offset_ret)
 {
        struct btrfs_key min_key;
-        struct btrfs_key max_key;
        struct btrfs_root *log = root->log_root;
        struct extent_buffer *src;
        int err = 0;
@@ -2843,9 +2890,6 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
        u64 ino = btrfs_ino(inode);
        log = root->log_root;
-        max_key.objectid = ino;
-        max_key.offset = (u64)-1;
-        max_key.type = key_type;
        min_key.objectid = ino;
        min_key.type = key_type;
@@ -2853,8 +2897,7 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
        path->keep_locks = 1;
-        ret = btrfs_search_forward(root, &min_key, &max_key,
+        ret = btrfs_search_forward(root, &min_key, path, trans->transid);
-                                   path, trans->transid);
        /*
         * we didn't find anything from this transaction, see if there
@@ -2907,10 +2950,8 @@ static noinline int log_dir_items(struct btrfs_trans_handle *trans,
        /* find the first key from this transaction again */
        ret = btrfs_search_slot(NULL, root, &min_key, path, 0, 0);
-        if (ret != 0) {
+        if (WARN_ON(ret != 0))
-                WARN_ON(1);
                goto done;
-        }
        /*
         * we have a block from this transaction, log every item in it
@@ -3136,11 +3177,10 @@ static int log_inode_item(struct btrfs_trans_handle *trans,
                          struct inode *inode)
 {
        struct btrfs_inode_item *inode_item;
-        struct btrfs_key key;
        int ret;
-        memcpy(&key, &BTRFS_I(inode)->location, sizeof(key));
+        ret = btrfs_insert_empty_item(trans, log, path,
-        ret = btrfs_insert_empty_item(trans, log, path, &key,
+                                      &BTRFS_I(inode)->location,
                                      sizeof(*inode_item));
        if (ret && ret != -EEXIST)
                return ret;
@@ -3339,7 +3379,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,
                btrfs_set_token_file_extent_type(leaf, fi,
                                                 BTRFS_FILE_EXTENT_REG,
                                                 &token);
-                if (em->block_start == 0)
+                if (em->block_start == EXTENT_MAP_HOLE)
                        skip_csum = true;
        }
@@ -3381,11 +3421,6 @@ static int log_one_extent(struct btrfs_trans_handle *trans,
        if (skip_csum)
                return 0;
-        if (em->compress_type) {
-                csum_offset = 0;
-                csum_len = block_len;
-        }
        /*
         * First check and see if our csums are on our outstanding ordered
         * extents.
@@ -3469,8 +3504,13 @@ unlocked:
        if (!mod_len || ret)
                return ret;
-        csum_offset = mod_start - em->start;
+        if (em->compress_type) {
-        csum_len = mod_len;
+                csum_offset = 0;
+                csum_len = block_len;
+        } else {
+                csum_offset = mod_start - em->start;
+                csum_len = mod_len;
+        }
        /* block start is already adjusted for the file extent offset. */
        ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
@@ -3657,7 +3697,8 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                        ret = btrfs_truncate_inode_items(trans, log,
                                                         inode, 0, 0);
                } else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
-                                              &BTRFS_I(inode)->runtime_flags)) {
+                                              &BTRFS_I(inode)->runtime_flags) ||
+                           inode_only == LOG_INODE_EXISTS) {
                        if (inode_only == LOG_INODE_ALL)
                                fast_search = true;
                        max_key.type = BTRFS_XATTR_ITEM_KEY;
@@ -3683,7 +3724,7 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
        while (1) {
                ins_nr = 0;
-                ret = btrfs_search_forward(root, &min_key, &max_key,
+                ret = btrfs_search_forward(root, &min_key,
                                           path, trans->transid);
                if (ret != 0)
                        break;
@@ -3733,14 +3774,14 @@ next_slot:
                }
                btrfs_release_path(path);
-                if (min_key.offset < (u64)-1)
+                if (min_key.offset < (u64)-1) {
                        min_key.offset++;
-                else if (min_key.type < (u8)-1)
+                } else if (min_key.type < max_key.type) {
                        min_key.type++;
-                else if (min_key.objectid < (u64)-1)
+                        min_key.offset = 0;
-                        min_key.objectid++;
+                } else {
-                else
                        break;
+                }
        }
        if (ins_nr) {
                ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
@@ -3761,7 +3802,7 @@ log_extents:
                        err = ret;
                        goto out_unlock;
                }
-        } else {
+        } else if (inode_only == LOG_INODE_ALL) {
                struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
                struct extent_map *em, *n;
@@ -3805,6 +3846,7 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
        int ret = 0;
        struct btrfs_root *root;
        struct dentry *old_parent = NULL;
+        struct inode *orig_inode = inode;
        /*
         * for regular files, if its inode is already on disk, we don't
@@ -3824,7 +3866,14 @@ static noinline int check_parent_dirs_for_sync(struct btrfs_trans_handle *trans,
        }
        while (1) {
-                BTRFS_I(inode)->logged_trans = trans->transid;
+                /*
+                 * If we are logging a directory then we start with our inode,
+                 * not our parents inode, so we need to skipp setting the
+                 * logged_trans so that further down in the log code we don't
+                 * think this inode has already been logged.
+                 */
+                if (inode != orig_inode)
+                        BTRFS_I(inode)->logged_trans = trans->transid;
                smp_mb();
                if (BTRFS_I(inode)->last_unlink_trans > last_committed) {
diff --git a/fs/btrfs/uuid-tree.c b/fs/btrfs/uuid-tree.c
index dd0dea3766f7..fbda90004fe9 100644
--- a/fs/btrfs/uuid-tree.c
+++ b/fs/btrfs/uuid-tree.c
@@ -260,7 +260,6 @@ int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
 {
        struct btrfs_root *root = fs_info->uuid_root;
        struct btrfs_key key;
-        struct btrfs_key max_key;
        struct btrfs_path *path;
        int ret = 0;
        struct extent_buffer *leaf;
@@ -277,13 +276,10 @@ int btrfs_uuid_tree_iterate(struct btrfs_fs_info *fs_info,
        key.objectid = 0;
        key.type = 0;
        key.offset = 0;
-        max_key.objectid = (u64)-1;
-        max_key.type = (u8)-1;
-        max_key.offset = (u64)-1;
 again_search_slot:
        path->keep_locks = 1;
-        ret = btrfs_search_forward(root, &key, &max_key, path, 0);
+        ret = btrfs_search_forward(root, &key, path, 0);
        if (ret) {
                if (ret > 0)
                        ret = 0;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 0052ca8264d9..92303f42baaa 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -28,7 +28,6 @@
 #include <linux/raid/pq.h>
 #include <linux/semaphore.h>
 #include <asm/div64.h>
-#include "compat.h"
 #include "ctree.h"
 #include "extent_map.h"
 #include "disk-io.h"
@@ -666,7 +665,8 @@ static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
                if (device->bdev)
                        fs_devices->open_devices--;
-                if (device->writeable && !device->is_tgtdev_for_dev_replace) {
+                if (device->writeable &&
+                    device->devid != BTRFS_DEV_REPLACE_DEVID) {
                        list_del_init(&device->dev_alloc_list);
                        fs_devices->rw_devices--;
                }
@@ -796,7 +796,8 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
                        fs_devices->rotating = 1;
                fs_devices->open_devices++;
-                if (device->writeable && !device->is_tgtdev_for_dev_replace) {
+                if (device->writeable &&
+                    device->devid != BTRFS_DEV_REPLACE_DEVID) {
                        fs_devices->rw_devices++;
                        list_add(&device->dev_alloc_list,
                                 &fs_devices->alloc_list);
@@ -911,9 +912,9 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
        if (disk_super->label[0]) {
                if (disk_super->label[BTRFS_LABEL_SIZE - 1])
                        disk_super->label[BTRFS_LABEL_SIZE - 1] = '\0';
-                printk(KERN_INFO "device label %s ", disk_super->label);
+                printk(KERN_INFO "btrfs: device label %s ", disk_super->label);
        } else {
-                printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
+                printk(KERN_INFO "btrfs: device fsid %pU ", disk_super->fsid);
        }
        printk(KERN_CONT "devid %llu transid %llu %s\n", devid, transid, path);
@@ -1715,6 +1716,7 @@ void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
                                 struct btrfs_device *srcdev)
 {
        WARN_ON(!mutex_is_locked(&fs_info->fs_devices->device_list_mutex));
        list_del_rcu(&srcdev->dev_list);
        list_del_rcu(&srcdev->dev_alloc_list);
        fs_info->fs_devices->num_devices--;
@@ -1724,9 +1726,13 @@ void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
        }
        if (srcdev->can_discard)
                fs_info->fs_devices->num_can_discard--;
-        if (srcdev->bdev)
+        if (srcdev->bdev) {
                fs_info->fs_devices->open_devices--;
+                /* zero out the old super */
+                btrfs_scratch_superblock(srcdev);
+        }
        call_rcu(&srcdev->rcu, free_device);
 }
@@ -2035,6 +2041,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
        device->in_fs_metadata = 1;
        device->is_tgtdev_for_dev_replace = 0;
        device->mode = FMODE_EXCL;
+        device->dev_stats_valid = 1;
        set_blocksize(device->bdev, 4096);
        if (seeding_dev) {
@@ -2202,6 +2209,7 @@ int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
        device->in_fs_metadata = 1;
        device->is_tgtdev_for_dev_replace = 1;
        device->mode = FMODE_EXCL;
+        device->dev_stats_valid = 1;
        set_blocksize(device->bdev, 4096);
        device->fs_devices = fs_info->fs_devices;
        list_add(&device->dev_list, &fs_info->fs_devices->devices);
@@ -2544,8 +2552,7 @@ again:
                failed = 0;
                retried = true;
                goto again;
-        } else if (failed && retried) {
+        } else if (WARN_ON(failed && retried)) {
-                WARN_ON(1);
                ret = -ENOSPC;
        }
 error:
@@ -3417,6 +3424,9 @@ int btrfs_pause_balance(struct btrfs_fs_info *fs_info)
 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info)
 {
+        if (fs_info->sb->s_flags & MS_RDONLY)
+                return -EROFS;
        mutex_lock(&fs_info->balance_mutex);
        if (!fs_info->balance_ctl) {
                mutex_unlock(&fs_info->balance_mutex);
@@ -3482,7 +3492,7 @@ static int btrfs_uuid_scan_kthread(void *data)
        path->keep_locks = 1;
        while (1) {
-                ret = btrfs_search_forward(root, &key, &max_key, path, 0);
+                ret = btrfs_search_forward(root, &key, path, 0);
                if (ret) {
                        if (ret > 0)
                                ret = 0;
@@ -4482,6 +4492,7 @@ int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
                btrfs_crit(fs_info, "Invalid mapping for %Lu-%Lu, got "
                            "%Lu-%Lu\n", logical, logical+len, em->start,
                            em->start + em->len);
+                free_extent_map(em);
                return 1;
        }
@@ -4662,6 +4673,7 @@ static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                btrfs_crit(fs_info, "found a bad mapping, wanted %Lu, "
                           "found %Lu-%Lu\n", logical, em->start,
                           em->start + em->len);
+                free_extent_map(em);
                return -EINVAL;
        }
@@ -4889,7 +4901,7 @@ static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                        num_stripes = map->num_stripes;
                        max_errors = nr_parity_stripes(map);
-                        raid_map = kmalloc(sizeof(u64) * num_stripes,
+                        raid_map = kmalloc_array(num_stripes, sizeof(u64),
                                           GFP_NOFS);
                        if (!raid_map) {
                                ret = -ENOMEM;
@@ -5382,17 +5394,15 @@ static int bio_size_ok(struct block_device *bdev, struct bio *bio,
 {
        struct bio_vec *prev;
        struct request_queue *q = bdev_get_queue(bdev);
-        unsigned short max_sectors = queue_max_sectors(q);
+        unsigned int max_sectors = queue_max_sectors(q);
        struct bvec_merge_data bvm = {
                .bi_bdev = bdev,
                .bi_sector = sector,
                .bi_rw = bio->bi_rw,
        };
-        if (bio->bi_vcnt == 0) {
+        if (WARN_ON(bio->bi_vcnt == 0))
-                WARN_ON(1);
                return 1;
-        }
        prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
        if (bio_sectors(bio) > max_sectors)
@@ -5625,10 +5635,8 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
        struct btrfs_device *dev;
        u64 tmp;
-        if (!devid && !fs_info) {
+        if (WARN_ON(!devid && !fs_info))
-                WARN_ON(1);
                return ERR_PTR(-EINVAL);
-        }
        dev = __alloc_device();
        if (IS_ERR(dev))
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index b72f540c8b29..8b3cd142b373 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -43,9 +43,8 @@ struct btrfs_device {
        /* WRITE_SYNC bios */
        struct btrfs_pending_bios pending_sync_bios;
-        int running_pending;
        u64 generation;
+        int running_pending;
        int writeable;
        int in_fs_metadata;
        int missing;
@@ -53,11 +52,11 @@ struct btrfs_device {
        int is_tgtdev_for_dev_replace;
        spinlock_t io_lock;
+        /* the mode sent to blkdev_get */
+        fmode_t mode;
        struct block_device *bdev;
-        /* the mode sent to blkdev_get */
-        fmode_t mode;
        struct rcu_string *name;
@@ -78,16 +77,21 @@ struct btrfs_device {
        /* optimal io width for this device */
        u32 io_width;
+        /* type and info about this device */
+        u64 type;
        /* minimal io size for this device */
        u32 sector_size;
-        /* type and info about this device */
-        u64 type;
        /* physical drive uuid (or lvm uuid) */
        u8 uuid[BTRFS_UUID_SIZE];
+        /* for sending down flush barriers */
+        int nobarriers;
+        struct bio *flush_bio;
+        struct completion flush_wait;
        /* per-device scrub information */
        struct scrub_ctx *scrub_device;
@@ -103,10 +107,6 @@ struct btrfs_device {
        struct radix_tree_root reada_zones;
        struct radix_tree_root reada_extents;
-        /* for sending down flush barriers */
-        struct bio *flush_bio;
-        struct completion flush_wait;
-        int nobarriers;
        /* disk I/O failure stats. For detailed description refer to
         * enum btrfs_dev_stat_values in ioctl.h */
@@ -132,7 +132,9 @@ struct btrfs_fs_devices {
        /* all of the devices in the FS, protected by a mutex
         * so we can safely walk it to write out the supers without
-         * worrying about add/remove by the multi-device code
+         * worrying about add/remove by the multi-device code.
+         * Scrubbing super can kick off supers writing by holding
+         * this mutex lock.
         */
        struct mutex device_list_mutex;
        struct list_head devices;
author	Michal Marek <mmarek@suse.cz>	2014-01-02 08:02:06 -0500
committer	Michal Marek <mmarek@suse.cz>	2014-01-02 08:02:06 -0500
commit	37e2c2a775fc887acd1432908478dfd532f7f00f (patch)
tree	e51ebc699d8e262fd47e0913be6a711cb1a7b565 /fs/btrfs
parent	1c8ddae09f4c102b97c9086cc70347e89468a547 (diff)
parent	6ce4eac1f600b34f2f7f58f9cd8f0503d79e42ae (diff)