50 files changed, 8749 insertions, 3198 deletions

diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
index d7fcdba141a2..7df3e0f0ee51 100644
--- a/fs/btrfs/Makefile
+++ b/fs/btrfs/Makefile
@@ -8,7 +8,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
            extent_io.o volumes.o async-thread.o ioctl.o locking.o orphan.o \
            export.o tree-log.o free-space-cache.o zlib.o lzo.o \
            compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \
-           reada.o backref.o ulist.o qgroup.o send.o
+           reada.o backref.o ulist.o qgroup.o send.o dev-replace.o
 
 btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
 btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
diff --git a/fs/btrfs/acl.c b/fs/btrfs/acl.c
index 0c16e3dbfd56..e15d2b0d8d3b 100644
--- a/fs/btrfs/acl.c
+++ b/fs/btrfs/acl.c
@@ -121,6 +121,8 @@ static int btrfs_set_acl(struct btrfs_trans_handle *trans,
                         ret = posix_acl_equiv_mode(acl, &inode->i_mode);
                         if (ret < 0)
                                 return ret;
+                        if (ret == 0)
+                                acl = NULL;
                 }
                 ret = 0;
                 break;
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index ff6475f409d6..04edf69be875 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -16,6 +16,7 @@
  * Boston, MA 021110-1307, USA.
  */
 
+#include <linux/vmalloc.h>
 #include "ctree.h"
 #include "disk-io.h"
 #include "backref.h"
@@ -231,7 +232,7 @@ static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
                         }
                         if (!ret) {
                                 ret = ulist_add(parents, eb->start,
-                                                (unsigned long)eie, GFP_NOFS);
+                                                (uintptr_t)eie, GFP_NOFS);
                                 if (ret < 0)
                                         break;
                                 if (!extent_item_pos) {
@@ -282,9 +283,7 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
                 goto out;
         }
 
-        rcu_read_lock();
-        root_level = btrfs_header_level(root->node);
-        rcu_read_unlock();
+        root_level = btrfs_old_root_level(root, time_seq);
 
         if (root_level + 1 == level)
                 goto out;
@@ -363,8 +362,8 @@ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
                 ULIST_ITER_INIT(&uiter);
                 node = ulist_next(parents, &uiter);
                 ref->parent = node ? node->val : 0;
-                ref->inode_list =
-                        node ? (struct extent_inode_elem *)node->aux : 0;
+                ref->inode_list = node ?
+                        (struct extent_inode_elem *)(uintptr_t)node->aux : 0;
 
                 /* additional parents require new refs being added here */
                 while ((node = ulist_next(parents, &uiter))) {
@@ -375,8 +374,8 @@ static int __resolve_indirect_refs(struct btrfs_fs_info *fs_info,
                         }
                         memcpy(new_ref, ref, sizeof(*ref));
                         new_ref->parent = node->val;
-                        new_ref->inode_list =
-                                        (struct extent_inode_elem *)node->aux;
+                        new_ref->inode_list = (struct extent_inode_elem *)
+                                                        (uintptr_t)node->aux;
                         list_add(&new_ref->list, &ref->list);
                 }
                 ulist_reinit(parents);
@@ -462,6 +461,7 @@ static int __merge_refs(struct list_head *head, int mode)
                      pos2 = n2, n2 = pos2->next) {
                         struct __prelim_ref *ref2;
                         struct __prelim_ref *xchg;
+                        struct extent_inode_elem *eie;
 
                         ref2 = list_entry(pos2, struct __prelim_ref, list);
 
@@ -473,12 +473,20 @@ static int __merge_refs(struct list_head *head, int mode)
                                         ref1 = ref2;
                                         ref2 = xchg;
                                 }
-                                ref1->count += ref2->count;
                         } else {
                                 if (ref1->parent != ref2->parent)
                                         continue;
-                                ref1->count += ref2->count;
                         }
+
+                        eie = ref1->inode_list;
+                        while (eie && eie->next)
+                                eie = eie->next;
+                        if (eie)
+                                eie->next = ref2->inode_list;
+                        else
+                                ref1->inode_list = ref2->inode_list;
+                        ref1->count += ref2->count;
+
                         list_del(&ref2->list);
                         kfree(ref2);
                 }
@@ -891,8 +899,7 @@ again:
         while (!list_empty(&prefs)) {
                 ref = list_first_entry(&prefs, struct __prelim_ref, list);
                 list_del(&ref->list);
-                if (ref->count < 0)
-                        WARN_ON(1);
+                WARN_ON(ref->count < 0);
                 if (ref->count && ref->root_id && ref->parent == 0) {
                         /* no parent == root of tree */
                         ret = ulist_add(roots, ref->root_id, 0, GFP_NOFS);
@@ -914,8 +921,8 @@ again:
                                 free_extent_buffer(eb);
                         }
                         ret = ulist_add_merge(refs, ref->parent,
-                                              (unsigned long)ref->inode_list,
-                                              (unsigned long *)&eie, GFP_NOFS);
+                                              (uintptr_t)ref->inode_list,
+                                              (u64 *)&eie, GFP_NOFS);
                         if (!ret && extent_item_pos) {
                                 /*
                                  * we've recorded that parent, so we must extend
@@ -959,7 +966,7 @@ static void free_leaf_list(struct ulist *blocks)
         while ((node = ulist_next(blocks, &uiter))) {
                 if (!node->aux)
                         continue;
-                eie = (struct extent_inode_elem *)node->aux;
+                eie = (struct extent_inode_elem *)(uintptr_t)node->aux;
                 for (; eie; eie = eie_next) {
                         eie_next = eie->next;
                         kfree(eie);
@@ -1108,44 +1115,97 @@ static int inode_ref_info(u64 inum, u64 ioff, struct btrfs_root *fs_root,
                                 found_key);
 }
 
-/*
- * this iterates to turn a btrfs_inode_ref into a full filesystem path. elements
- * of the path are separated by '/' and the path is guaranteed to be
- * 0-terminated. the path is only given within the current file system.
- * Therefore, it never starts with a '/'. the caller is responsible to provide
- * "size" bytes in "dest". the dest buffer will be filled backwards. finally,
- * the start point of the resulting string is returned. this pointer is within
- * dest, normally.
- * in case the path buffer would overflow, the pointer is decremented further
- * as if output was written to the buffer, though no more output is actually
- * generated. that way, the caller can determine how much space would be
- * required for the path to fit into the buffer. in that case, the returned
- * value will be smaller than dest. callers must check this!
- */
-char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
-                         struct btrfs_inode_ref *iref,
-                         struct extent_buffer *eb_in, u64 parent,
-                         char *dest, u32 size)
+int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid,
+                          u64 start_off, struct btrfs_path *path,
+                          struct btrfs_inode_extref **ret_extref,
+                          u64 *found_off)
+{
+        int ret, slot;
+        struct btrfs_key key;
+        struct btrfs_key found_key;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        unsigned long ptr;
+
+        key.objectid = inode_objectid;
+        btrfs_set_key_type(&key, BTRFS_INODE_EXTREF_KEY);
+        key.offset = start_off;
+
+        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+        if (ret < 0)
+                return ret;
+
+        while (1) {
+                leaf = path->nodes[0];
+                slot = path->slots[0];
+                if (slot >= btrfs_header_nritems(leaf)) {
+                        /*
+                         * If the item at offset is not found,
+                         * btrfs_search_slot will point us to the slot
+                         * where it should be inserted. In our case
+                         * that will be the slot directly before the
+                         * next INODE_REF_KEY_V2 item. In the case
+                         * that we're pointing to the last slot in a
+                         * leaf, we must move one leaf over.
+                         */
+                        ret = btrfs_next_leaf(root, path);
+                        if (ret) {
+                                if (ret >= 1)
+                                        ret = -ENOENT;
+                                break;
+                        }
+                        continue;
+                }
+
+                btrfs_item_key_to_cpu(leaf, &found_key, slot);
+
+                /*
+                 * Check that we're still looking at an extended ref key for
+                 * this particular objectid. If we have different
+                 * objectid or type then there are no more to be found
+                 * in the tree and we can exit.
+                 */
+                ret = -ENOENT;
+                if (found_key.objectid != inode_objectid)
+                        break;
+                if (btrfs_key_type(&found_key) != BTRFS_INODE_EXTREF_KEY)
+                        break;
+
+                ret = 0;
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+                extref = (struct btrfs_inode_extref *)ptr;
+                *ret_extref = extref;
+                if (found_off)
+                        *found_off = found_key.offset;
+                break;
+        }
+
+        return ret;
+}
+
+char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
+                        u32 name_len, unsigned long name_off,
+                        struct extent_buffer *eb_in, u64 parent,
+                        char *dest, u32 size)
 {
-        u32 len;
         int slot;
         u64 next_inum;
         int ret;
-        s64 bytes_left = size - 1;
+        s64 bytes_left = ((s64)size) - 1;
         struct extent_buffer *eb = eb_in;
         struct btrfs_key found_key;
         int leave_spinning = path->leave_spinning;
+        struct btrfs_inode_ref *iref;
 
         if (bytes_left >= 0)
                 dest[bytes_left] = '\0';
 
         path->leave_spinning = 1;
         while (1) {
-                len = btrfs_inode_ref_name_len(eb, iref);
-                bytes_left -= len;
+                bytes_left -= name_len;
                 if (bytes_left >= 0)
                         read_extent_buffer(eb, dest + bytes_left,
-                                                (unsigned long)(iref + 1), len);
+                                           name_off, name_len);
                 if (eb != eb_in) {
                         btrfs_tree_read_unlock_blocking(eb);
                         free_extent_buffer(eb);
@@ -1155,6 +1215,7 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
                         ret = -ENOENT;
                 if (ret)
                         break;
+
                 next_inum = found_key.offset;
 
                 /* regular exit ahead */
@@ -1170,8 +1231,11 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
                         btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
                 }
                 btrfs_release_path(path);
-
                 iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
+
+                name_len = btrfs_inode_ref_name_len(eb, iref);
+                name_off = (unsigned long)(iref + 1);
+
                 parent = next_inum;
                 --bytes_left;
                 if (bytes_left >= 0)
@@ -1188,12 +1252,39 @@ char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
 }
 
 /*
+ * this iterates to turn a btrfs_inode_ref into a full filesystem path. elements
+ * of the path are separated by '/' and the path is guaranteed to be
+ * 0-terminated. the path is only given within the current file system.
+ * Therefore, it never starts with a '/'. the caller is responsible to provide
+ * "size" bytes in "dest". the dest buffer will be filled backwards. finally,
+ * the start point of the resulting string is returned. this pointer is within
+ * dest, normally.
+ * in case the path buffer would overflow, the pointer is decremented further
+ * as if output was written to the buffer, though no more output is actually
+ * generated. that way, the caller can determine how much space would be
+ * required for the path to fit into the buffer. in that case, the returned
+ * value will be smaller than dest. callers must check this!
+ */
+char *btrfs_iref_to_path(struct btrfs_root *fs_root,
+                         struct btrfs_path *path,
+                         struct btrfs_inode_ref *iref,
+                         struct extent_buffer *eb_in, u64 parent,
+                         char *dest, u32 size)
+{
+        return btrfs_ref_to_path(fs_root, path,
+                                 btrfs_inode_ref_name_len(eb_in, iref),
+                                 (unsigned long)(iref + 1),
+                                 eb_in, parent, dest, size);
+}
+
+/*
  * this makes the path point to (logical EXTENT_ITEM *)
  * returns BTRFS_EXTENT_FLAG_DATA for data, BTRFS_EXTENT_FLAG_TREE_BLOCK for
  * tree blocks and <0 on error.
  */
 int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
-                        struct btrfs_path *path, struct btrfs_key *found_key)
+                        struct btrfs_path *path, struct btrfs_key *found_key,
+                        u64 *flags_ret)
 {
         int ret;
         u64 flags;
@@ -1237,10 +1328,17 @@ int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
                  (unsigned long long)found_key->objectid,
                  (unsigned long long)found_key->offset,
                  (unsigned long long)flags, item_size);
-        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
-                return BTRFS_EXTENT_FLAG_TREE_BLOCK;
-        if (flags & BTRFS_EXTENT_FLAG_DATA)
-                return BTRFS_EXTENT_FLAG_DATA;
+
+        WARN_ON(!flags_ret);
+        if (flags_ret) {
+                if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+                        *flags_ret = BTRFS_EXTENT_FLAG_TREE_BLOCK;
+                else if (flags & BTRFS_EXTENT_FLAG_DATA)
+                        *flags_ret = BTRFS_EXTENT_FLAG_DATA;
+                else
+                        BUG_ON(1);
+                return 0;
+        }
 
         return -EIO;
 }
@@ -1404,12 +1502,13 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
                 ULIST_ITER_INIT(&root_uiter);
                 while (!ret && (root_node = ulist_next(roots, &root_uiter))) {
                         pr_debug("root %llu references leaf %llu, data list "
-                                 "%#lx\n", root_node->val, ref_node->val,
-                                 ref_node->aux);
-                        ret = iterate_leaf_refs(
-                                (struct extent_inode_elem *)ref_node->aux,
-                                root_node->val, extent_item_objectid,
-                                iterate, ctx);
+                                 "%#llx\n", root_node->val, ref_node->val,
+                                 (long long)ref_node->aux);
+                        ret = iterate_leaf_refs((struct extent_inode_elem *)
+                                                (uintptr_t)ref_node->aux,
+                                                root_node->val,
+                                                extent_item_objectid,
+                                                iterate, ctx);
                 }
                 ulist_free(roots);
                 roots = NULL;
@@ -1432,15 +1531,15 @@ int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
 {
         int ret;
         u64 extent_item_pos;
+        u64 flags = 0;
         struct btrfs_key found_key;
         int search_commit_root = path->search_commit_root;
 
-        ret = extent_from_logical(fs_info, logical, path,
-                                        &found_key);
+        ret = extent_from_logical(fs_info, logical, path, &found_key, &flags);
         btrfs_release_path(path);
         if (ret < 0)
                 return ret;
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
                 return -EINVAL;
 
         extent_item_pos = logical - found_key.objectid;
@@ -1451,9 +1550,12 @@ int iterate_inodes_from_logical(u64 logical, struct btrfs_fs_info *fs_info,
         return ret;
 }
 
-static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
-                                struct btrfs_path *path,
-                                iterate_irefs_t *iterate, void *ctx)
+typedef int (iterate_irefs_t)(u64 parent, u32 name_len, unsigned long name_off,
+                              struct extent_buffer *eb, void *ctx);
+
+static int iterate_inode_refs(u64 inum, struct btrfs_root *fs_root,
+                              struct btrfs_path *path,
+                              iterate_irefs_t *iterate, void *ctx)
 {
         int ret = 0;
         int slot;
@@ -1470,7 +1572,7 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
         while (!ret) {
                 path->leave_spinning = 1;
                 ret = inode_ref_info(inum, parent ? parent+1 : 0, fs_root, path,
-                                        &found_key);
+                                     &found_key);
                 if (ret < 0)
                         break;
                 if (ret) {
@@ -1498,7 +1600,8 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
                                  "tree %llu\n", cur,
                                  (unsigned long long)found_key.objectid,
                                  (unsigned long long)fs_root->objectid);
-                        ret = iterate(parent, iref, eb, ctx);
+                        ret = iterate(parent, name_len,
+                                      (unsigned long)(iref + 1), eb, ctx);
                         if (ret)
                                 break;
                         len = sizeof(*iref) + name_len;
@@ -1513,12 +1616,98 @@ static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
         return ret;
 }
 
+static int iterate_inode_extrefs(u64 inum, struct btrfs_root *fs_root,
+                                 struct btrfs_path *path,
+                                 iterate_irefs_t *iterate, void *ctx)
+{
+        int ret;
+        int slot;
+        u64 offset = 0;
+        u64 parent;
+        int found = 0;
+        struct extent_buffer *eb;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        u32 item_size;
+        u32 cur_offset;
+        unsigned long ptr;
+
+        while (1) {
+                ret = btrfs_find_one_extref(fs_root, inum, offset, path, &extref,
+                                            &offset);
+                if (ret < 0)
+                        break;
+                if (ret) {
+                        ret = found ? 0 : -ENOENT;
+                        break;
+                }
+                ++found;
+
+                slot = path->slots[0];
+                eb = path->nodes[0];
+                /* make sure we can use eb after releasing the path */
+                atomic_inc(&eb->refs);
+
+                btrfs_tree_read_lock(eb);
+                btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
+                btrfs_release_path(path);
+
+                leaf = path->nodes[0];
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+                cur_offset = 0;
+
+                while (cur_offset < item_size) {
+                        u32 name_len;
+
+                        extref = (struct btrfs_inode_extref *)(ptr + cur_offset);
+                        parent = btrfs_inode_extref_parent(eb, extref);
+                        name_len = btrfs_inode_extref_name_len(eb, extref);
+                        ret = iterate(parent, name_len,
+                                      (unsigned long)&extref->name, eb, ctx);
+                        if (ret)
+                                break;
+
+                        cur_offset += btrfs_inode_extref_name_len(leaf, extref);
+                        cur_offset += sizeof(*extref);
+                }
+                btrfs_tree_read_unlock_blocking(eb);
+                free_extent_buffer(eb);
+
+                offset++;
+        }
+
+        btrfs_release_path(path);
+
+        return ret;
+}
+
+static int iterate_irefs(u64 inum, struct btrfs_root *fs_root,
+                         struct btrfs_path *path, iterate_irefs_t *iterate,
+                         void *ctx)
+{
+        int ret;
+        int found_refs = 0;
+
+        ret = iterate_inode_refs(inum, fs_root, path, iterate, ctx);
+        if (!ret)
+                ++found_refs;
+        else if (ret != -ENOENT)
+                return ret;
+
+        ret = iterate_inode_extrefs(inum, fs_root, path, iterate, ctx);
+        if (ret == -ENOENT && found_refs)
+                return 0;
+
+        return ret;
+}
+
 /*
  * returns 0 if the path could be dumped (probably truncated)
  * returns <0 in case of an error
  */
-static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
-                                struct extent_buffer *eb, void *ctx)
+static int inode_to_path(u64 inum, u32 name_len, unsigned long name_off,
+                         struct extent_buffer *eb, void *ctx)
 {
         struct inode_fs_paths *ipath = ctx;
         char *fspath;
@@ -1531,20 +1720,16 @@ static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
                                         ipath->fspath->bytes_left - s_ptr : 0;
 
         fspath_min = (char *)ipath->fspath->val + (i + 1) * s_ptr;
-        fspath = btrfs_iref_to_path(ipath->fs_root, ipath->btrfs_path, iref, eb,
-                                inum, fspath_min, bytes_left);
+        fspath = btrfs_ref_to_path(ipath->fs_root, ipath->btrfs_path, name_len,
+                                   name_off, eb, inum, fspath_min, bytes_left);
         if (IS_ERR(fspath))
                 return PTR_ERR(fspath);
 
         if (fspath > fspath_min) {
-                pr_debug("path resolved: %s\n", fspath);
                 ipath->fspath->val[i] = (u64)(unsigned long)fspath;
                 ++ipath->fspath->elem_cnt;
                 ipath->fspath->bytes_left = fspath - fspath_min;
         } else {
-                pr_debug("missed path, not enough space. missing bytes: %lu, "
-                         "constructed so far: %s\n",
-                         (unsigned long)(fspath_min - fspath), fspath_min);
                 ++ipath->fspath->elem_missed;
                 ipath->fspath->bytes_missing += fspath_min - fspath;
                 ipath->fspath->bytes_left = 0;
@@ -1566,7 +1751,7 @@ static int inode_to_path(u64 inum, struct btrfs_inode_ref *iref,
 int paths_from_inode(u64 inum, struct inode_fs_paths *ipath)
 {
         return iterate_irefs(inum, ipath->fs_root, ipath->btrfs_path,
-                                inode_to_path, ipath);
+                             inode_to_path, ipath);
 }
 
 struct btrfs_data_container *init_data_container(u32 total_bytes)
@@ -1575,7 +1760,7 @@ struct btrfs_data_container *init_data_container(u32 total_bytes)
         size_t alloc_bytes;
 
         alloc_bytes = max_t(size_t, total_bytes, sizeof(*data));
-        data = kmalloc(alloc_bytes, GFP_NOFS);
+        data = vmalloc(alloc_bytes);
         if (!data)
                 return ERR_PTR(-ENOMEM);
 
@@ -1626,6 +1811,6 @@ void free_ipath(struct inode_fs_paths *ipath)
 {
         if (!ipath)
                 return;
-        kfree(ipath->fspath);
+        vfree(ipath->fspath);
         kfree(ipath);
 }
diff --git a/fs/btrfs/backref.h b/fs/btrfs/backref.h
index 032f4dc7eab8..d61feca79455 100644
--- a/fs/btrfs/backref.h
+++ b/fs/btrfs/backref.h
@@ -33,14 +33,13 @@ struct inode_fs_paths {
 
 typedef int (iterate_extent_inodes_t)(u64 inum, u64 offset, u64 root,
                 void *ctx);
-typedef int (iterate_irefs_t)(u64 parent, struct btrfs_inode_ref *iref,
-                                struct extent_buffer *eb, void *ctx);
 
 int inode_item_info(u64 inum, u64 ioff, struct btrfs_root *fs_root,
                         struct btrfs_path *path);
 
 int extent_from_logical(struct btrfs_fs_info *fs_info, u64 logical,
-                        struct btrfs_path *path, struct btrfs_key *found_key);
+                        struct btrfs_path *path, struct btrfs_key *found_key,
+                        u64 *flags);
 
 int tree_backref_for_extent(unsigned long *ptr, struct extent_buffer *eb,
                                 struct btrfs_extent_item *ei, u32 item_size,
@@ -63,10 +62,19 @@ int btrfs_find_all_roots(struct btrfs_trans_handle *trans,
 char *btrfs_iref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
                          struct btrfs_inode_ref *iref, struct extent_buffer *eb,
                          u64 parent, char *dest, u32 size);
+char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path,
+                        u32 name_len, unsigned long name_off,
+                        struct extent_buffer *eb_in, u64 parent,
+                        char *dest, u32 size);
 
 struct btrfs_data_container *init_data_container(u32 total_bytes);
 struct inode_fs_paths *init_ipath(s32 total_bytes, struct btrfs_root *fs_root,
                                         struct btrfs_path *path);
 void free_ipath(struct inode_fs_paths *ipath);
 
+int btrfs_find_one_extref(struct btrfs_root *root, u64 inode_objectid,
+                          u64 start_off, struct btrfs_path *path,
+                          struct btrfs_inode_extref **ret_extref,
+                          u64 *found_off);
+
 #endif
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 5b2ad6bc4fe7..2a8c242bc4f5 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -38,6 +38,8 @@
 #define BTRFS_INODE_DELALLOC_META_RESERVED      4
 #define BTRFS_INODE_HAS_ORPHAN_ITEM             5
 #define BTRFS_INODE_HAS_ASYNC_EXTENT            6
+#define BTRFS_INODE_NEEDS_FULL_SYNC             7
+#define BTRFS_INODE_COPY_EVERYTHING             8
 
 /* in memory btrfs inode */
 struct btrfs_inode {
@@ -89,6 +91,9 @@ struct btrfs_inode {
 
         unsigned long runtime_flags;
 
+        /* Keep track of who's O_SYNC/fsycing currently */
+        atomic_t sync_writers;
+
         /* full 64 bit generation number, struct vfs_inode doesn't have a big
          * enough field for this.
          */
@@ -143,6 +148,9 @@ struct btrfs_inode {
         /* flags field from the on disk inode */
         u32 flags;
 
+        /* a local copy of root's last_log_commit */
+        unsigned long last_log_commit;
+
         /*
          * Counters to keep track of the number of extent item's we may use due
          * to delalloc and such.  outstanding_extents is the number of extent
@@ -202,15 +210,10 @@ static inline bool btrfs_is_free_space_inode(struct inode *inode)
 
 static inline int btrfs_inode_in_log(struct inode *inode, u64 generation)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        int ret = 0;
-
-        mutex_lock(&root->log_mutex);
         if (BTRFS_I(inode)->logged_trans == generation &&
-            BTRFS_I(inode)->last_sub_trans <= root->last_log_commit)
-                ret = 1;
-        mutex_unlock(&root->log_mutex);
-        return ret;
+            BTRFS_I(inode)->last_sub_trans <= BTRFS_I(inode)->last_log_commit)
+                return 1;
+        return 0;
 }
 
 #endif
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index 9197e2e33407..11d47bfb62b4 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -37,8 +37,9 @@
  *        the file system was mounted, (i.e., they have been
  *        referenced by the super block) or they have been
  *        written since then and the write completion callback
- *        was called and a FLUSH request to the device where
- *        these blocks are located was received and completed.
+ *        was called and no write error was indicated and a
+ *        FLUSH request to the device where these blocks are
+ *        located was received and completed.
  *    2b. All referenced blocks need to have a generation
  *        number which is equal to the parent's number.
  *
@@ -136,7 +137,7 @@ struct btrfsic_block {
         unsigned int never_written:1;   /* block was added because it was
                                          * referenced, not because it was
                                          * written */
-        unsigned int mirror_num:2;      /* large enough to hold
+        unsigned int mirror_num;        /* large enough to hold
                                          * BTRFS_SUPER_MIRROR_MAX */
         struct btrfsic_dev_state *dev_state;
         u64 dev_bytenr;         /* key, physical byte num on disk */
@@ -722,7 +723,7 @@ static int btrfsic_process_superblock(struct btrfsic_state *state,
                 }
 
                 num_copies =
-                    btrfs_num_copies(&state->root->fs_info->mapping_tree,
+                    btrfs_num_copies(state->root->fs_info,
                                      next_bytenr, state->metablock_size);
                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
@@ -902,7 +903,7 @@ static int btrfsic_process_superblock_dev_mirror(
                 }
 
                 num_copies =
-                    btrfs_num_copies(&state->root->fs_info->mapping_tree,
+                    btrfs_num_copies(state->root->fs_info,
                                      next_bytenr, state->metablock_size);
                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
@@ -1286,7 +1287,7 @@ static int btrfsic_create_link_to_next_block(
         *next_blockp = NULL;
         if (0 == *num_copiesp) {
                 *num_copiesp =
-                    btrfs_num_copies(&state->root->fs_info->mapping_tree,
+                    btrfs_num_copies(state->root->fs_info,
                                      next_bytenr, state->metablock_size);
                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
@@ -1488,7 +1489,7 @@ static int btrfsic_handle_extent_data(
                         chunk_len = num_bytes;
 
                 num_copies =
-                    btrfs_num_copies(&state->root->fs_info->mapping_tree,
+                    btrfs_num_copies(state->root->fs_info,
                                      next_bytenr, state->datablock_size);
                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
@@ -1581,9 +1582,21 @@ static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len,
         struct btrfs_device *device;
 
         length = len;
-        ret = btrfs_map_block(&state->root->fs_info->mapping_tree, READ,
+        ret = btrfs_map_block(state->root->fs_info, READ,
                               bytenr, &length, &multi, mirror_num);
 
+        if (ret) {
+                block_ctx_out->start = 0;
+                block_ctx_out->dev_bytenr = 0;
+                block_ctx_out->len = 0;
+                block_ctx_out->dev = NULL;
+                block_ctx_out->datav = NULL;
+                block_ctx_out->pagev = NULL;
+                block_ctx_out->mem_to_free = NULL;
+
+                return ret;
+        }
+
         device = multi->stripes[0].dev;
         block_ctx_out->dev = btrfsic_dev_state_lookup(device->bdev);
         block_ctx_out->dev_bytenr = multi->stripes[0].physical;
@@ -1593,8 +1606,7 @@ static int btrfsic_map_block(struct btrfsic_state *state, u64 bytenr, u32 len,
         block_ctx_out->pagev = NULL;
         block_ctx_out->mem_to_free = NULL;
 
-        if (0 == ret)
-                kfree(multi);
+        kfree(multi);
         if (NULL == block_ctx_out->dev) {
                 ret = -ENXIO;
                 printk(KERN_INFO "btrfsic: error, cannot lookup dev (#1)!\n");
@@ -2462,7 +2474,7 @@ static int btrfsic_process_written_superblock(
                 }
 
                 num_copies =
-                    btrfs_num_copies(&state->root->fs_info->mapping_tree,
+                    btrfs_num_copies(state->root->fs_info,
                                      next_bytenr, BTRFS_SUPER_INFO_SIZE);
                 if (state->print_mask & BTRFSIC_PRINT_MASK_NUM_COPIES)
                         printk(KERN_INFO "num_copies(log_bytenr=%llu) = %d\n",
@@ -2601,6 +2613,17 @@ static int btrfsic_check_all_ref_blocks(struct btrfsic_state *state,
                                (unsigned long long)l->block_ref_to->dev_bytenr,
                                l->block_ref_to->mirror_num);
                         ret = -1;
+                } else if (l->block_ref_to->iodone_w_error) {
+                        printk(KERN_INFO "btrfs: attempt to write superblock"
+                               " which references block %c @%llu (%s/%llu/%d)"
+                               " which has write error!\n",
+                               btrfsic_get_block_type(state, l->block_ref_to),
+                               (unsigned long long)
+                               l->block_ref_to->logical_bytenr,
+                               l->block_ref_to->dev_state->name,
+                               (unsigned long long)l->block_ref_to->dev_bytenr,
+                               l->block_ref_to->mirror_num);
+                        ret = -1;
                 } else if (l->parent_generation !=
                            l->block_ref_to->generation &&
                            BTRFSIC_GENERATION_UNKNOWN !=
@@ -2948,7 +2971,7 @@ static void btrfsic_cmp_log_and_dev_bytenr(struct btrfsic_state *state,
         struct btrfsic_block_data_ctx block_ctx;
         int match = 0;
 
-        num_copies = btrfs_num_copies(&state->root->fs_info->mapping_tree,
+        num_copies = btrfs_num_copies(state->root->fs_info,
                                       bytenr, state->metablock_size);
 
         for (mirror_num = 1; mirror_num <= num_copies; mirror_num++) {
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 43d1c5a3a030..94ab2f80e7e3 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -577,6 +577,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         u64 em_start;
         struct extent_map *em;
         int ret = -ENOMEM;
+        int faili = 0;
         u32 *sums;
 
         tree = &BTRFS_I(inode)->io_tree;
@@ -626,9 +627,13 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         for (pg_index = 0; pg_index < nr_pages; pg_index++) {
                 cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS |
                                                               __GFP_HIGHMEM);
-                if (!cb->compressed_pages[pg_index])
+                if (!cb->compressed_pages[pg_index]) {
+                        faili = pg_index - 1;
+                        ret = -ENOMEM;
                         goto fail2;
+                }
         }
+        faili = nr_pages - 1;
         cb->nr_pages = nr_pages;
 
         add_ra_bio_pages(inode, em_start + em_len, cb);
@@ -682,7 +687,8 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 
                         ret = btrfs_map_bio(root, READ, comp_bio,
                                             mirror_num, 0);
-                        BUG_ON(ret); /* -ENOMEM */
+                        if (ret)
+                                bio_endio(comp_bio, ret);
 
                         bio_put(comp_bio);
 
@@ -707,14 +713,17 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         }
 
         ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
-        BUG_ON(ret); /* -ENOMEM */
+        if (ret)
+                bio_endio(comp_bio, ret);
 
         bio_put(comp_bio);
         return 0;
 
 fail2:
-        for (pg_index = 0; pg_index < nr_pages; pg_index++)
-                free_page((unsigned long)cb->compressed_pages[pg_index]);
+        while (faili >= 0) {
+                __free_page(cb->compressed_pages[faili]);
+                faili--;
+        }
 
         kfree(cb->compressed_pages);
 fail1:
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 6d183f60d63a..c7b67cf24bba 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -38,8 +38,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans,
                               struct extent_buffer *dst_buf,
                               struct extent_buffer *src_buf);
 static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct btrfs_path *path, int level, int slot,
-                    int tree_mod_log);
+                    struct btrfs_path *path, int level, int slot);
 static void tree_mod_log_free_eb(struct btrfs_fs_info *fs_info,
                                  struct extent_buffer *eb);
 struct extent_buffer *read_old_tree_block(struct btrfs_root *root, u64 bytenr,
@@ -596,6 +595,11 @@ tree_mod_log_insert_move(struct btrfs_fs_info *fs_info,
         if (tree_mod_dont_log(fs_info, eb))
                 return 0;
 
+        /*
+         * When we override something during the move, we log these removals.
+         * This can only happen when we move towards the beginning of the
+         * buffer, i.e. dst_slot < src_slot.
+         */
         for (i = 0; i + dst_slot < src_slot && i < nr_items; i++) {
                 ret = tree_mod_log_insert_key_locked(fs_info, eb, i + dst_slot,
                                               MOD_LOG_KEY_REMOVE_WHILE_MOVING);
@@ -647,8 +651,6 @@ tree_mod_log_insert_root(struct btrfs_fs_info *fs_info,
         if (tree_mod_dont_log(fs_info, NULL))
                 return 0;
 
-        __tree_mod_log_free_eb(fs_info, old_root);
-
         ret = tree_mod_alloc(fs_info, flags, &tm);
         if (ret < 0)
                 goto out;
@@ -773,8 +775,7 @@ tree_mod_log_eb_move(struct btrfs_fs_info *fs_info, struct extent_buffer *dst,
 
 static noinline void
 tree_mod_log_set_node_key(struct btrfs_fs_info *fs_info,
-                          struct extent_buffer *eb,
-                          struct btrfs_disk_key *disk_key, int slot, int atomic)
+                          struct extent_buffer *eb, int slot, int atomic)
 {
         int ret;
 
@@ -926,12 +927,7 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans,
                         ret = btrfs_dec_ref(trans, root, buf, 1, 1);
                         BUG_ON(ret); /* -ENOMEM */
                 }
-                /*
-                 * don't log freeing in case we're freeing the root node, this
-                 * is done by tree_mod_log_set_root_pointer later
-                 */
-                if (buf != root->node && btrfs_header_level(buf) != 0)
-                        tree_mod_log_free_eb(root->fs_info, buf);
+                tree_mod_log_free_eb(root->fs_info, buf);
                 clean_tree_block(trans, root, buf);
                 *last_ref = 1;
         }
@@ -1142,13 +1138,13 @@ __tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
                 switch (tm->op) {
                 case MOD_LOG_KEY_REMOVE_WHILE_FREEING:
                         BUG_ON(tm->slot < n);
-                case MOD_LOG_KEY_REMOVE_WHILE_MOVING:
                 case MOD_LOG_KEY_REMOVE:
+                        n++;
+                case MOD_LOG_KEY_REMOVE_WHILE_MOVING:
                         btrfs_set_node_key(eb, &tm->key, tm->slot);
                         btrfs_set_node_blockptr(eb, tm->slot, tm->blockptr);
                         btrfs_set_node_ptr_generation(eb, tm->slot,
                                                       tm->generation);
-                        n++;
                         break;
                 case MOD_LOG_KEY_REPLACE:
                         BUG_ON(tm->slot >= n);
@@ -1225,6 +1221,8 @@ tree_mod_log_rewind(struct btrfs_fs_info *fs_info, struct extent_buffer *eb,
         free_extent_buffer(eb);
 
         __tree_mod_log_rewind(eb_rewin, time_seq, tm);
+        WARN_ON(btrfs_header_nritems(eb_rewin) >
+                BTRFS_NODEPTRS_PER_BLOCK(fs_info->fs_root));
 
         return eb_rewin;
 }
@@ -1241,9 +1239,11 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
 {
         struct tree_mod_elem *tm;
         struct extent_buffer *eb;
+        struct extent_buffer *old;
         struct tree_mod_root *old_root = NULL;
         u64 old_generation = 0;
         u64 logical;
+        u32 blocksize;
 
         eb = btrfs_read_lock_root_node(root);
         tm = __tree_mod_log_oldest_root(root->fs_info, root, time_seq);
@@ -1259,14 +1259,32 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
         }
 
         tm = tree_mod_log_search(root->fs_info, logical, time_seq);
-        if (old_root)
+        if (old_root && tm && tm->op != MOD_LOG_KEY_REMOVE_WHILE_FREEING) {
+                btrfs_tree_read_unlock(root->node);
+                free_extent_buffer(root->node);
+                blocksize = btrfs_level_size(root, old_root->level);
+                old = read_tree_block(root, logical, blocksize, 0);
+                if (!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);
+                }
+        } else if (old_root) {
+                btrfs_tree_read_unlock(root->node);
+                free_extent_buffer(root->node);
                 eb = alloc_dummy_extent_buffer(logical, root->nodesize);
-        else
+        } else {
                 eb = btrfs_clone_extent_buffer(root->node);
-        btrfs_tree_read_unlock(root->node);
-        free_extent_buffer(root->node);
+                btrfs_tree_read_unlock(root->node);
+                free_extent_buffer(root->node);
+        }
+
         if (!eb)
                 return NULL;
+        extent_buffer_get(eb);
         btrfs_tree_read_lock(eb);
         if (old_root) {
                 btrfs_set_header_bytenr(eb, eb->start);
@@ -1279,11 +1297,28 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
                 __tree_mod_log_rewind(eb, time_seq, tm);
         else
                 WARN_ON(btrfs_header_level(eb) != 0);
-        extent_buffer_get(eb);
+        WARN_ON(btrfs_header_nritems(eb) > BTRFS_NODEPTRS_PER_BLOCK(root));
 
         return eb;
 }
 
+int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq)
+{
+        struct tree_mod_elem *tm;
+        int level;
+
+        tm = __tree_mod_log_oldest_root(root->fs_info, root, time_seq);
+        if (tm && tm->op == MOD_LOG_ROOT_REPLACE) {
+                level = tm->old_root.level;
+        } else {
+                rcu_read_lock();
+                level = btrfs_header_level(root->node);
+                rcu_read_unlock();
+        }
+
+        return level;
+}
+
 static inline int should_cow_block(struct btrfs_trans_handle *trans,
                                    struct btrfs_root *root,
                                    struct extent_buffer *buf)
@@ -1324,19 +1359,16 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
         u64 search_start;
         int ret;
 
-        if (trans->transaction != root->fs_info->running_transaction) {
-                printk(KERN_CRIT "trans %llu running %llu\n",
+        if (trans->transaction != root->fs_info->running_transaction)
+                WARN(1, KERN_CRIT "trans %llu running %llu\n",
                        (unsigned long long)trans->transid,
                        (unsigned long long)
                        root->fs_info->running_transaction->transid);
-                WARN_ON(1);
-        }
-        if (trans->transid != root->fs_info->generation) {
-                printk(KERN_CRIT "trans %llu running %llu\n",
+
+        if (trans->transid != root->fs_info->generation)
+                WARN(1, KERN_CRIT "trans %llu running %llu\n",
                        (unsigned long long)trans->transid,
                        (unsigned long long)root->fs_info->generation);
-                WARN_ON(1);
-        }
 
         if (!should_cow_block(trans, root, buf)) {
                 *cow_ret = buf;
@@ -1432,10 +1464,8 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
         if (cache_only && parent_level != 1)
                 return 0;
 
-        if (trans->transaction != root->fs_info->running_transaction)
-                WARN_ON(1);
-        if (trans->transid != root->fs_info->generation)
-                WARN_ON(1);
+        WARN_ON(trans->transaction != root->fs_info->running_transaction);
+        WARN_ON(trans->transid != root->fs_info->generation);
 
         parent_nritems = btrfs_header_nritems(parent);
         blocksize = btrfs_level_size(root, parent_level - 1);
@@ -1725,6 +1755,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                         goto enospc;
                 }
 
+                tree_mod_log_free_eb(root->fs_info, root->node);
                 tree_mod_log_set_root_pointer(root, child);
                 rcu_assign_pointer(root->node, child);
 
@@ -1789,7 +1820,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                 if (btrfs_header_nritems(right) == 0) {
                         clean_tree_block(trans, root, right);
                         btrfs_tree_unlock(right);
-                        del_ptr(trans, root, path, level + 1, pslot + 1, 1);
+                        del_ptr(trans, root, path, level + 1, pslot + 1);
                         root_sub_used(root, right->len);
                         btrfs_free_tree_block(trans, root, right, 0, 1);
                         free_extent_buffer_stale(right);
@@ -1798,7 +1829,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                         struct btrfs_disk_key right_key;
                         btrfs_node_key(right, &right_key, 0);
                         tree_mod_log_set_node_key(root->fs_info, parent,
-                                                  &right_key, pslot + 1, 0);
+                                                  pslot + 1, 0);
                         btrfs_set_node_key(parent, &right_key, pslot + 1);
                         btrfs_mark_buffer_dirty(parent);
                 }
@@ -1833,7 +1864,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
         if (btrfs_header_nritems(mid) == 0) {
                 clean_tree_block(trans, root, mid);
                 btrfs_tree_unlock(mid);
-                del_ptr(trans, root, path, level + 1, pslot, 1);
+                del_ptr(trans, root, path, level + 1, pslot);
                 root_sub_used(root, mid->len);
                 btrfs_free_tree_block(trans, root, mid, 0, 1);
                 free_extent_buffer_stale(mid);
@@ -1842,7 +1873,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                 /* update the parent key to reflect our changes */
                 struct btrfs_disk_key mid_key;
                 btrfs_node_key(mid, &mid_key, 0);
-                tree_mod_log_set_node_key(root->fs_info, parent, &mid_key,
+                tree_mod_log_set_node_key(root->fs_info, parent,
                                           pslot, 0);
                 btrfs_set_node_key(parent, &mid_key, pslot);
                 btrfs_mark_buffer_dirty(parent);
@@ -1942,7 +1973,7 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
                         orig_slot += left_nr;
                         btrfs_node_key(mid, &disk_key, 0);
                         tree_mod_log_set_node_key(root->fs_info, parent,
-                                                  &disk_key, pslot, 0);
+                                                  pslot, 0);
                         btrfs_set_node_key(parent, &disk_key, pslot);
                         btrfs_mark_buffer_dirty(parent);
                         if (btrfs_header_nritems(left) > orig_slot) {
@@ -1995,7 +2026,7 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
 
                         btrfs_node_key(right, &disk_key, 0);
                         tree_mod_log_set_node_key(root->fs_info, parent,
-                                                  &disk_key, pslot + 1, 0);
+                                                  pslot + 1, 0);
                         btrfs_set_node_key(parent, &disk_key, pslot + 1);
                         btrfs_mark_buffer_dirty(parent);
 
@@ -2181,6 +2212,9 @@ static noinline void unlock_up(struct btrfs_path *path, int level,
         int no_skips = 0;
         struct extent_buffer *t;
 
+        if (path->really_keep_locks)
+                return;
+
         for (i = level; i < BTRFS_MAX_LEVEL; i++) {
                 if (!path->nodes[i])
                         break;
@@ -2228,7 +2262,7 @@ noinline void btrfs_unlock_up_safe(struct btrfs_path *path, int level)
 {
         int i;
 
-        if (path->keep_locks)
+        if (path->keep_locks || path->really_keep_locks)
                 return;
 
         for (i = level; i < BTRFS_MAX_LEVEL; i++) {
@@ -2461,7 +2495,7 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root
         if (!cow)
                 write_lock_level = -1;
 
-        if (cow && (p->keep_locks || p->lowest_level))
+        if (cow && (p->really_keep_locks || p->keep_locks || p->lowest_level))
                 write_lock_level = BTRFS_MAX_LEVEL;
 
         min_write_lock_level = write_lock_level;
@@ -2530,7 +2564,10 @@ again:
                          * must have write locks on this node and the
                          * parent
                          */
-                        if (level + 1 > write_lock_level) {
+                        if (level > write_lock_level ||
+                            (level + 1 > write_lock_level &&
+                            level + 1 < BTRFS_MAX_LEVEL &&
+                            p->nodes[level + 1])) {
                                 write_lock_level = level + 1;
                                 btrfs_release_path(p);
                                 goto again;
@@ -2879,7 +2916,7 @@ static void fixup_low_keys(struct btrfs_trans_handle *trans,
                 if (!path->nodes[i])
                         break;
                 t = path->nodes[i];
-                tree_mod_log_set_node_key(root->fs_info, t, key, tslot, 1);
+                tree_mod_log_set_node_key(root->fs_info, t, tslot, 1);
                 btrfs_set_node_key(t, key, tslot);
                 btrfs_mark_buffer_dirty(path->nodes[i]);
                 if (tslot != 0)
@@ -2970,8 +3007,10 @@ static int push_node_left(struct btrfs_trans_handle *trans,
                            push_items * sizeof(struct btrfs_key_ptr));
 
         if (push_items < src_nritems) {
-                tree_mod_log_eb_move(root->fs_info, src, 0, push_items,
-                                     src_nritems - push_items);
+                /*
+                 * don't call tree_mod_log_eb_move here, key removal was already
+                 * fully logged by tree_mod_log_eb_copy above.
+                 */
                 memmove_extent_buffer(src, btrfs_node_key_ptr_offset(0),
                                       btrfs_node_key_ptr_offset(push_items),
                                       (src_nritems - push_items) *
@@ -3262,14 +3301,21 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
  */
 static int leaf_space_used(struct extent_buffer *l, int start, int nr)
 {
+        struct btrfs_item *start_item;
+        struct btrfs_item *end_item;
+        struct btrfs_map_token token;
         int data_len;
         int nritems = btrfs_header_nritems(l);
         int end = min(nritems, start + nr) - 1;
 
         if (!nr)
                 return 0;
-        data_len = btrfs_item_end_nr(l, start);
-        data_len = data_len - btrfs_item_offset_nr(l, end);
+        btrfs_init_map_token(&token);
+        start_item = btrfs_item_nr(l, start);
+        end_item = btrfs_item_nr(l, 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);
         data_len += sizeof(struct btrfs_item) * nr;
         WARN_ON(data_len < 0);
         return data_len;
@@ -3363,8 +3409,7 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
         if (push_items == 0)
                 goto out_unlock;
 
-        if (!empty && push_items == left_nritems)
-                WARN_ON(1);
+        WARN_ON(!empty && push_items == left_nritems);
 
         /* push left to right */
         right_nritems = btrfs_header_nritems(right);
@@ -3602,11 +3647,9 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
         btrfs_set_header_nritems(left, old_left_nritems + push_items);
 
         /* fixup right node */
-        if (push_items > right_nritems) {
-                printk(KERN_CRIT "push items %d nr %u\n", push_items,
+        if (push_items > right_nritems)
+                WARN(1, KERN_CRIT "push items %d nr %u\n", push_items,
                        right_nritems);
-                WARN_ON(1);
-        }
 
         if (push_items < right_nritems) {
                 push_space = btrfs_item_offset_nr(right, push_items - 1) -
@@ -4402,149 +4445,6 @@ void btrfs_extend_item(struct btrfs_trans_handle *trans,
 }
 
 /*
- * Given a key and some data, insert items into the tree.
- * This does all the path init required, making room in the tree if needed.
- * Returns the number of keys that were inserted.
- */
-int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
-                            struct btrfs_root *root,
-                            struct btrfs_path *path,
-                            struct btrfs_key *cpu_key, u32 *data_size,
-                            int nr)
-{
-        struct extent_buffer *leaf;
-        struct btrfs_item *item;
-        int ret = 0;
-        int slot;
-        int i;
-        u32 nritems;
-        u32 total_data = 0;
-        u32 total_size = 0;
-        unsigned int data_end;
-        struct btrfs_disk_key disk_key;
-        struct btrfs_key found_key;
-        struct btrfs_map_token token;
-
-        btrfs_init_map_token(&token);
-
-        for (i = 0; i < nr; i++) {
-                if (total_size + data_size[i] + sizeof(struct btrfs_item) >
-                    BTRFS_LEAF_DATA_SIZE(root)) {
-                        break;
-                        nr = i;
-                }
-                total_data += data_size[i];
-                total_size += data_size[i] + sizeof(struct btrfs_item);
-        }
-        BUG_ON(nr == 0);
-
-        ret = btrfs_search_slot(trans, root, cpu_key, path, total_size, 1);
-        if (ret == 0)
-                return -EEXIST;
-        if (ret < 0)
-                goto out;
-
-        leaf = path->nodes[0];
-
-        nritems = btrfs_header_nritems(leaf);
-        data_end = leaf_data_end(root, leaf);
-
-        if (btrfs_leaf_free_space(root, leaf) < total_size) {
-                for (i = nr; i >= 0; i--) {
-                        total_data -= data_size[i];
-                        total_size -= data_size[i] + sizeof(struct btrfs_item);
-                        if (total_size < btrfs_leaf_free_space(root, leaf))
-                                break;
-                }
-                nr = i;
-        }
-
-        slot = path->slots[0];
-        BUG_ON(slot < 0);
-
-        if (slot != nritems) {
-                unsigned int old_data = btrfs_item_end_nr(leaf, slot);
-
-                item = btrfs_item_nr(leaf, slot);
-                btrfs_item_key_to_cpu(leaf, &found_key, slot);
-
-                /* figure out how many keys we can insert in here */
-                total_data = data_size[0];
-                for (i = 1; i < nr; i++) {
-                        if (btrfs_comp_cpu_keys(&found_key, cpu_key + i) <= 0)
-                                break;
-                        total_data += data_size[i];
-                }
-                nr = i;
-
-                if (old_data < data_end) {
-                        btrfs_print_leaf(root, leaf);
-                        printk(KERN_CRIT "slot %d old_data %d data_end %d\n",
-                               slot, old_data, data_end);
-                        BUG_ON(1);
-                }
-                /*
-                 * item0..itemN ... dataN.offset..dataN.size .. data0.size
-                 */
-                /* first correct the data pointers */
-                for (i = slot; i < nritems; i++) {
-                        u32 ioff;
-
-                        item = btrfs_item_nr(leaf, i);
-                        ioff = btrfs_token_item_offset(leaf, item, &token);
-                        btrfs_set_token_item_offset(leaf, item,
-                                                    ioff - total_data, &token);
-                }
-                /* shift the items */
-                memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
-                              btrfs_item_nr_offset(slot),
-                              (nritems - slot) * sizeof(struct btrfs_item));
-
-                /* shift the data */
-                memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
-                              data_end - total_data, btrfs_leaf_data(leaf) +
-                              data_end, old_data - data_end);
-                data_end = old_data;
-        } else {
-                /*
-                 * this sucks but it has to be done, if we are inserting at
-                 * the end of the leaf only insert 1 of the items, since we
-                 * have no way of knowing whats on the next leaf and we'd have
-                 * to drop our current locks to figure it out
-                 */
-                nr = 1;
-        }
-
-        /* setup the item for the new data */
-        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);
-                btrfs_set_token_item_offset(leaf, item,
-                                            data_end - data_size[i], &token);
-                data_end -= data_size[i];
-                btrfs_set_token_item_size(leaf, item, data_size[i], &token);
-        }
-        btrfs_set_header_nritems(leaf, nritems + nr);
-        btrfs_mark_buffer_dirty(leaf);
-
-        ret = 0;
-        if (slot == 0) {
-                btrfs_cpu_key_to_disk(&disk_key, cpu_key);
-                fixup_low_keys(trans, root, path, &disk_key, 1);
-        }
-
-        if (btrfs_leaf_free_space(root, leaf) < 0) {
-                btrfs_print_leaf(root, leaf);
-                BUG();
-        }
-out:
-        if (!ret)
-                ret = nr;
-        return ret;
-}
-
-/*
  * this is a helper for btrfs_insert_empty_items, the main goal here is
  * to save stack depth by doing the bulk of the work in a function
  * that doesn't call btrfs_search_slot
@@ -4705,16 +4605,21 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root
  * empty a node.
  */
 static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
-                    struct btrfs_path *path, int level, int slot,
-                    int tree_mod_log)
+                    struct btrfs_path *path, int level, int slot)
 {
         struct extent_buffer *parent = path->nodes[level];
         u32 nritems;
         int ret;
 
+        if (level) {
+                ret = tree_mod_log_insert_key(root->fs_info, parent, slot,
+                                              MOD_LOG_KEY_REMOVE);
+                BUG_ON(ret < 0);
+        }
+
         nritems = btrfs_header_nritems(parent);
         if (slot != nritems - 1) {
-                if (tree_mod_log && level)
+                if (level)
                         tree_mod_log_eb_move(root->fs_info, parent, slot,
                                              slot + 1, nritems - slot - 1);
                 memmove_extent_buffer(parent,
@@ -4722,10 +4627,6 @@ static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                               btrfs_node_key_ptr_offset(slot + 1),
                               sizeof(struct btrfs_key_ptr) *
                               (nritems - slot - 1));
-        } else if (tree_mod_log && level) {
-                ret = tree_mod_log_insert_key(root->fs_info, parent, slot,
-                                              MOD_LOG_KEY_REMOVE);
-                BUG_ON(ret < 0);
         }
 
         nritems--;
@@ -4759,7 +4660,7 @@ static noinline void btrfs_del_leaf(struct btrfs_trans_handle *trans,
                                     struct extent_buffer *leaf)
 {
         WARN_ON(btrfs_header_generation(leaf) != trans->transid);
-        del_ptr(trans, root, path, 1, path->slots[1], 1);
+        del_ptr(trans, root, path, 1, path->slots[1]);
 
         /*
          * btrfs_free_extent is expensive, we want to make sure we
@@ -5073,6 +4974,7 @@ static void tree_move_down(struct btrfs_root *root,
                            struct btrfs_path *path,
                            int *level, int root_level)
 {
+        BUG_ON(*level == 0);
         path->nodes[*level - 1] = read_node_slot(root, path->nodes[*level],
                                         path->slots[*level]);
         path->slots[*level - 1] = 0;
@@ -5089,7 +4991,7 @@ static int tree_move_next_or_upnext(struct btrfs_root *root,
 
         path->slots[*level]++;
 
-        while (path->slots[*level] == nritems) {
+        while (path->slots[*level] >= nritems) {
                 if (*level == root_level)
                         return -1;
 
@@ -5225,13 +5127,13 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
         right_path->search_commit_root = 1;
         right_path->skip_locking = 1;
 
-        spin_lock(&left_root->root_times_lock);
+        spin_lock(&left_root->root_item_lock);
         left_start_ctransid = btrfs_root_ctransid(&left_root->root_item);
-        spin_unlock(&left_root->root_times_lock);
+        spin_unlock(&left_root->root_item_lock);
 
-        spin_lock(&right_root->root_times_lock);
+        spin_lock(&right_root->root_item_lock);
         right_start_ctransid = btrfs_root_ctransid(&right_root->root_item);
-        spin_unlock(&right_root->root_times_lock);
+        spin_unlock(&right_root->root_item_lock);
 
         trans = btrfs_join_transaction(left_root);
         if (IS_ERR(trans)) {
@@ -5326,15 +5228,15 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
                                 goto out;
                         }
 
-                        spin_lock(&left_root->root_times_lock);
+                        spin_lock(&left_root->root_item_lock);
                         ctransid = btrfs_root_ctransid(&left_root->root_item);
-                        spin_unlock(&left_root->root_times_lock);
+                        spin_unlock(&left_root->root_item_lock);
                         if (ctransid != left_start_ctransid)
                                 left_start_ctransid = 0;
 
-                        spin_lock(&right_root->root_times_lock);
+                        spin_lock(&right_root->root_item_lock);
                         ctransid = btrfs_root_ctransid(&right_root->root_item);
-                        spin_unlock(&right_root->root_times_lock);
+                        spin_unlock(&right_root->root_item_lock);
                         if (ctransid != right_start_ctransid)
                                 right_start_ctransid = 0;
 
@@ -5433,9 +5335,11 @@ int btrfs_compare_trees(struct btrfs_root *left_root,
                                         goto out;
                                 advance_right = ADVANCE;
                         } else {
+                                WARN_ON(!extent_buffer_uptodate(left_path->nodes[0]));
                                 ret = tree_compare_item(left_root, left_path,
                                                 right_path, tmp_buf);
                                 if (ret) {
+                                        WARN_ON(!extent_buffer_uptodate(left_path->nodes[0]));
                                         ret = changed_cb(left_root, right_root,
                                                 left_path, right_path,
                                                 &left_key,
@@ -5596,6 +5500,139 @@ int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path)
         return btrfs_next_old_leaf(root, path, 0);
 }
 
+/* Release the path up to but not including the given level */
+static void btrfs_release_level(struct btrfs_path *path, int level)
+{
+        int i;
+
+        for (i = 0; i < level; i++) {
+                path->slots[i] = 0;
+                if (!path->nodes[i])
+                        continue;
+                if (path->locks[i]) {
+                        btrfs_tree_unlock_rw(path->nodes[i], path->locks[i]);
+                        path->locks[i] = 0;
+                }
+                free_extent_buffer(path->nodes[i]);
+                path->nodes[i] = NULL;
+        }
+}
+
+/*
+ * This function assumes 2 things
+ *
+ * 1) You are using path->keep_locks
+ * 2) You are not inserting items.
+ *
+ * If either of these are not true do not use this function. If you need a next
+ * leaf with either of these not being true then this function can be easily
+ * adapted to do that, but at the moment these are the limitations.
+ */
+int btrfs_next_leaf_write(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root, struct btrfs_path *path,
+                          int del)
+{
+        struct extent_buffer *b;
+        struct btrfs_key key;
+        u32 nritems;
+        int level = 1;
+        int slot;
+        int ret = 1;
+        int write_lock_level = BTRFS_MAX_LEVEL;
+        int ins_len = del ? -1 : 0;
+
+        WARN_ON(!(path->keep_locks || path->really_keep_locks));
+
+        nritems = btrfs_header_nritems(path->nodes[0]);
+        btrfs_item_key_to_cpu(path->nodes[0], &key, nritems - 1);
+
+        while (path->nodes[level]) {
+                nritems = btrfs_header_nritems(path->nodes[level]);
+                if (!(path->locks[level] & BTRFS_WRITE_LOCK)) {
+search:
+                        btrfs_release_path(path);
+                        ret = btrfs_search_slot(trans, root, &key, path,
+                                                ins_len, 1);
+                        if (ret < 0)
+                                goto out;
+                        level = 1;
+                        continue;
+                }
+
+                if (path->slots[level] >= nritems - 1) {
+                        level++;
+                        continue;
+                }
+
+                btrfs_release_level(path, level);
+                break;
+        }
+
+        if (!path->nodes[level]) {
+                ret = 1;
+                goto out;
+        }
+
+        path->slots[level]++;
+        b = path->nodes[level];
+
+        while (b) {
+                level = btrfs_header_level(b);
+
+                if (!should_cow_block(trans, root, b))
+                        goto cow_done;
+
+                btrfs_set_path_blocking(path);
+                ret = btrfs_cow_block(trans, root, b,
+                                      path->nodes[level + 1],
+                                      path->slots[level + 1], &b);
+                if (ret)
+                        goto out;
+cow_done:
+                path->nodes[level] = b;
+                btrfs_clear_path_blocking(path, NULL, 0);
+                if (level != 0) {
+                        ret = setup_nodes_for_search(trans, root, path, b,
+                                                     level, ins_len,
+                                                     &write_lock_level);
+                        if (ret == -EAGAIN)
+                                goto search;
+                        if (ret)
+                                goto out;
+
+                        b = path->nodes[level];
+                        slot = path->slots[level];
+
+                        ret = read_block_for_search(trans, root, path,
+                                                    &b, level, slot, &key, 0);
+                        if (ret == -EAGAIN)
+                                goto search;
+                        if (ret)
+                                goto out;
+                        level = btrfs_header_level(b);
+                        if (!btrfs_try_tree_write_lock(b)) {
+                                btrfs_set_path_blocking(path);
+                                btrfs_tree_lock(b);
+                                btrfs_clear_path_blocking(path, b,
+                                                          BTRFS_WRITE_LOCK);
+                        }
+                        path->locks[level] = BTRFS_WRITE_LOCK;
+                        path->nodes[level] = b;
+                        path->slots[level] = 0;
+                } else {
+                        path->slots[level] = 0;
+                        ret = 0;
+                        break;
+                }
+        }
+
+out:
+        if (ret)
+                btrfs_release_path(path);
+
+        return ret;
+}
+
 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
                         u64 time_seq)
 {
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 9821b672f5a2..547b7b05727f 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -48,7 +48,7 @@ struct btrfs_ordered_sum;
 
 #define BTRFS_MAGIC "_BHRfS_M"
 
-#define BTRFS_MAX_MIRRORS 2
+#define BTRFS_MAX_MIRRORS 3
 
 #define BTRFS_MAX_LEVEL 8
 
@@ -142,6 +142,8 @@ struct btrfs_ordered_sum;
 
 #define BTRFS_EMPTY_SUBVOL_DIR_OBJECTID 2
 
+#define BTRFS_DEV_REPLACE_DEVID 0
+
 /*
  * the max metadata block size.  This limit is somewhat artificial,
  * but the memmove costs go through the roof for larger blocks.
@@ -154,6 +156,13 @@ struct btrfs_ordered_sum;
  */
 #define BTRFS_NAME_LEN 255
 
+/*
+ * Theoretical limit is larger, but we keep this down to a sane
+ * value. That should limit greatly the possibility of collisions on
+ * inode ref items.
+ */
+#define BTRFS_LINK_MAX 65535U
+
 /* 32 bytes in various csum fields */
 #define BTRFS_CSUM_SIZE 32
 
@@ -165,6 +174,9 @@ static int btrfs_csum_sizes[] = { 4, 0 };
 /* four bytes for CRC32 */
 #define BTRFS_EMPTY_DIR_SIZE 0
 
+/* spefic to btrfs_map_block(), therefore not in include/linux/blk_types.h */
+#define REQ_GET_READ_MIRRORS    (1 << 30)
+
 #define BTRFS_FT_UNKNOWN        0
 #define BTRFS_FT_REG_FILE       1
 #define BTRFS_FT_DIR            2
@@ -406,7 +418,7 @@ struct btrfs_root_backup {
         __le64 bytes_used;
         __le64 num_devices;
         /* future */
-        __le64 unsed_64[4];
+        __le64 unused_64[4];
 
         u8 tree_root_level;
         u8 chunk_root_level;
@@ -489,6 +501,8 @@ struct btrfs_super_block {
  */
 #define BTRFS_FEATURE_INCOMPAT_BIG_METADATA     (1ULL << 5)
 
+#define BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF    (1ULL << 6)
+
 #define BTRFS_FEATURE_COMPAT_SUPP               0ULL
 #define BTRFS_FEATURE_COMPAT_RO_SUPP            0ULL
 #define BTRFS_FEATURE_INCOMPAT_SUPP                     \
@@ -496,7 +510,8 @@ struct btrfs_super_block {
          BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL |        \
          BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS |          \
          BTRFS_FEATURE_INCOMPAT_BIG_METADATA |          \
-         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO)
+         BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO |          \
+         BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
 
 /*
  * A leaf is full of items. offset and size tell us where to find
@@ -561,6 +576,7 @@ struct btrfs_path {
         unsigned int skip_locking:1;
         unsigned int leave_spinning:1;
         unsigned int search_commit_root:1;
+        unsigned int really_keep_locks:1;
 };
 
 /*
@@ -643,6 +659,14 @@ struct btrfs_inode_ref {
         /* name goes here */
 } __attribute__ ((__packed__));
 
+struct btrfs_inode_extref {
+        __le64 parent_objectid;
+        __le64 index;
+        __le16 name_len;
+        __u8   name[0];
+        /* name goes here */
+} __attribute__ ((__packed__));
+
 struct btrfs_timespec {
         __le64 sec;
         __le32 nsec;
@@ -867,6 +891,59 @@ struct btrfs_dev_stats_item {
         __le64 values[BTRFS_DEV_STAT_VALUES_MAX];
 } __attribute__ ((__packed__));
 
+#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS     0
+#define BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID      1
+#define BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED      0
+#define BTRFS_DEV_REPLACE_ITEM_STATE_STARTED            1
+#define BTRFS_DEV_REPLACE_ITEM_STATE_SUSPENDED          2
+#define BTRFS_DEV_REPLACE_ITEM_STATE_FINISHED           3
+#define BTRFS_DEV_REPLACE_ITEM_STATE_CANCELED           4
+
+struct btrfs_dev_replace {
+        u64 replace_state;      /* see #define above */
+        u64 time_started;       /* seconds since 1-Jan-1970 */
+        u64 time_stopped;       /* seconds since 1-Jan-1970 */
+        atomic64_t num_write_errors;
+        atomic64_t num_uncorrectable_read_errors;
+
+        u64 cursor_left;
+        u64 committed_cursor_left;
+        u64 cursor_left_last_write_of_item;
+        u64 cursor_right;
+
+        u64 cont_reading_from_srcdev_mode;      /* see #define above */
+
+        int is_valid;
+        int item_needs_writeback;
+        struct btrfs_device *srcdev;
+        struct btrfs_device *tgtdev;
+
+        pid_t lock_owner;
+        atomic_t nesting_level;
+        struct mutex lock_finishing_cancel_unmount;
+        struct mutex lock_management_lock;
+        struct mutex lock;
+
+        struct btrfs_scrub_progress scrub_progress;
+};
+
+struct btrfs_dev_replace_item {
+        /*
+         * grow this item struct at the end for future enhancements and keep
+         * the existing values unchanged
+         */
+        __le64 src_devid;
+        __le64 cursor_left;
+        __le64 cursor_right;
+        __le64 cont_reading_from_srcdev_mode;
+
+        __le64 replace_state;
+        __le64 time_started;
+        __le64 time_stopped;
+        __le64 num_write_errors;
+        __le64 num_uncorrectable_read_errors;
+} __attribute__ ((__packed__));
+
 /* different types of block groups (and chunks) */
 #define BTRFS_BLOCK_GROUP_DATA          (1ULL << 0)
 #define BTRFS_BLOCK_GROUP_SYSTEM        (1ULL << 1)
@@ -1028,12 +1105,22 @@ struct btrfs_space_info {
         wait_queue_head_t wait;
 };
 
+#define BTRFS_BLOCK_RSV_GLOBAL          1
+#define BTRFS_BLOCK_RSV_DELALLOC        2
+#define BTRFS_BLOCK_RSV_TRANS           3
+#define BTRFS_BLOCK_RSV_CHUNK           4
+#define BTRFS_BLOCK_RSV_DELOPS          5
+#define BTRFS_BLOCK_RSV_EMPTY           6
+#define BTRFS_BLOCK_RSV_TEMP            7
+
 struct btrfs_block_rsv {
         u64 size;
         u64 reserved;
         struct btrfs_space_info *space_info;
         spinlock_t lock;
-        unsigned int full;
+        unsigned short full;
+        unsigned short type;
+        unsigned short failfast;
 };
 
 /*
@@ -1127,6 +1214,9 @@ struct btrfs_block_group_cache {
          * Today it will only have one thing on it, but that may change
          */
         struct list_head cluster_list;
+
+        /* For delayed block group creation */
+        struct list_head new_bg_list;
 };
 
 /* delayed seq elem */
@@ -1240,7 +1330,6 @@ struct btrfs_fs_info {
         struct mutex reloc_mutex;
 
         struct list_head trans_list;
-        struct list_head hashers;
         struct list_head dead_roots;
         struct list_head caching_block_groups;
 
@@ -1303,6 +1392,7 @@ struct btrfs_fs_info {
         struct btrfs_workers generic_worker;
         struct btrfs_workers workers;
         struct btrfs_workers delalloc_workers;
+        struct btrfs_workers flush_workers;
         struct btrfs_workers endio_workers;
         struct btrfs_workers endio_meta_workers;
         struct btrfs_workers endio_meta_write_workers;
@@ -1366,9 +1456,6 @@ struct btrfs_fs_info {
         struct rb_root defrag_inodes;
         atomic_t defrag_running;
 
-        spinlock_t ref_cache_lock;
-        u64 total_ref_cache_size;
-
         /*
          * these three are in extended format (availability of single
          * chunks is denoted by BTRFS_AVAIL_ALLOC_BIT_SINGLE bit, other
@@ -1402,6 +1489,8 @@ struct btrfs_fs_info {
         struct rw_semaphore scrub_super_lock;
         int scrub_workers_refcnt;
         struct btrfs_workers scrub_workers;
+        struct btrfs_workers scrub_wr_completion_workers;
+        struct btrfs_workers scrub_nocow_workers;
 
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
         u32 check_integrity_print_mask;
@@ -1441,6 +1530,13 @@ struct btrfs_fs_info {
 
         /* next backup root to be overwritten */
         int backup_root_index;
+
+        int num_tolerated_disk_barrier_failures;
+
+        /* device replace state */
+        struct btrfs_dev_replace dev_replace;
+
+        atomic_t mutually_exclusive_operation_running;
 };
 
 /*
@@ -1481,9 +1577,9 @@ struct btrfs_root {
         wait_queue_head_t log_commit_wait[2];
         atomic_t log_writers;
         atomic_t log_commit[2];
+        atomic_t log_batch;
         unsigned long log_transid;
         unsigned long last_log_commit;
-        unsigned long log_batch;
         pid_t log_start_pid;
         bool log_multiple_pids;
 
@@ -1550,7 +1646,7 @@ struct btrfs_root {
 
         int force_cow;
 
-        spinlock_t root_times_lock;
+        spinlock_t root_item_lock;
 };
 
 struct btrfs_ioctl_defrag_range_args {
@@ -1592,6 +1688,7 @@ struct btrfs_ioctl_defrag_range_args {
  */
 #define BTRFS_INODE_ITEM_KEY            1
 #define BTRFS_INODE_REF_KEY             12
+#define BTRFS_INODE_EXTREF_KEY          13
 #define BTRFS_XATTR_ITEM_KEY            24
 #define BTRFS_ORPHAN_ITEM_KEY           48
 /* reserve 2-15 close to the inode for later flexibility */
@@ -1693,6 +1790,12 @@ struct btrfs_ioctl_defrag_range_args {
 #define BTRFS_DEV_STATS_KEY     249
 
 /*
+ * Persistantly stores the device replace state in the device tree.
+ * The key is built like this: (0, BTRFS_DEV_REPLACE_KEY, 0).
+ */
+#define BTRFS_DEV_REPLACE_KEY   250
+
+/*
  * string items are for debugging.  They just store a short string of
  * data in the FS
  */
@@ -1757,7 +1860,7 @@ struct btrfs_map_token {
 
 static inline void btrfs_init_map_token (struct btrfs_map_token *token)
 {
-        memset(token, 0, sizeof(*token));
+        token->kaddr = NULL;
 }
 
 /* some macros to generate set/get funcs for the struct fields.  This
@@ -1978,6 +2081,13 @@ BTRFS_SETGET_STACK_FUNCS(block_group_flags,
 BTRFS_SETGET_FUNCS(inode_ref_name_len, struct btrfs_inode_ref, name_len, 16);
 BTRFS_SETGET_FUNCS(inode_ref_index, struct btrfs_inode_ref, index, 64);
 
+/* struct btrfs_inode_extref */
+BTRFS_SETGET_FUNCS(inode_extref_parent, struct btrfs_inode_extref,
+                   parent_objectid, 64);
+BTRFS_SETGET_FUNCS(inode_extref_name_len, struct btrfs_inode_extref,
+                   name_len, 16);
+BTRFS_SETGET_FUNCS(inode_extref_index, struct btrfs_inode_extref, index, 64);
+
 /* struct btrfs_inode_item */
 BTRFS_SETGET_FUNCS(inode_generation, struct btrfs_inode_item, generation, 64);
 BTRFS_SETGET_FUNCS(inode_sequence, struct btrfs_inode_item, sequence, 64);
@@ -2718,6 +2828,49 @@ BTRFS_SETGET_FUNCS(qgroup_limit_rsv_rfer, struct btrfs_qgroup_limit_item,
 BTRFS_SETGET_FUNCS(qgroup_limit_rsv_excl, struct btrfs_qgroup_limit_item,
                    rsv_excl, 64);
 
+/* btrfs_dev_replace_item */
+BTRFS_SETGET_FUNCS(dev_replace_src_devid,
+                   struct btrfs_dev_replace_item, src_devid, 64);
+BTRFS_SETGET_FUNCS(dev_replace_cont_reading_from_srcdev_mode,
+                   struct btrfs_dev_replace_item, cont_reading_from_srcdev_mode,
+                   64);
+BTRFS_SETGET_FUNCS(dev_replace_replace_state, struct btrfs_dev_replace_item,
+                   replace_state, 64);
+BTRFS_SETGET_FUNCS(dev_replace_time_started, struct btrfs_dev_replace_item,
+                   time_started, 64);
+BTRFS_SETGET_FUNCS(dev_replace_time_stopped, struct btrfs_dev_replace_item,
+                   time_stopped, 64);
+BTRFS_SETGET_FUNCS(dev_replace_num_write_errors, struct btrfs_dev_replace_item,
+                   num_write_errors, 64);
+BTRFS_SETGET_FUNCS(dev_replace_num_uncorrectable_read_errors,
+                   struct btrfs_dev_replace_item, num_uncorrectable_read_errors,
+                   64);
+BTRFS_SETGET_FUNCS(dev_replace_cursor_left, struct btrfs_dev_replace_item,
+                   cursor_left, 64);
+BTRFS_SETGET_FUNCS(dev_replace_cursor_right, struct btrfs_dev_replace_item,
+                   cursor_right, 64);
+
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_src_devid,
+                         struct btrfs_dev_replace_item, src_devid, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cont_reading_from_srcdev_mode,
+                         struct btrfs_dev_replace_item,
+                         cont_reading_from_srcdev_mode, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_replace_state,
+                         struct btrfs_dev_replace_item, replace_state, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_started,
+                         struct btrfs_dev_replace_item, time_started, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_time_stopped,
+                         struct btrfs_dev_replace_item, time_stopped, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_write_errors,
+                         struct btrfs_dev_replace_item, num_write_errors, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_num_uncorrectable_read_errors,
+                         struct btrfs_dev_replace_item,
+                         num_uncorrectable_read_errors, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_left,
+                         struct btrfs_dev_replace_item, cursor_left, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_dev_replace_cursor_right,
+                         struct btrfs_dev_replace_item, cursor_right, 64);
+
 static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)
 {
         return sb->s_fs_info;
@@ -2858,9 +3011,23 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
                            u64 size);
 int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root, u64 group_start);
+void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
+                                       struct btrfs_root *root);
 u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags);
 u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data);
 void btrfs_clear_space_info_full(struct btrfs_fs_info *info);
+
+enum btrfs_reserve_flush_enum {
+        /* If we are in the transaction, we can't flush anything.*/
+        BTRFS_RESERVE_NO_FLUSH,
+        /*
+         * Flushing delalloc may cause deadlock somewhere, in this
+         * case, use FLUSH LIMIT
+         */
+        BTRFS_RESERVE_FLUSH_LIMIT,
+        BTRFS_RESERVE_FLUSH_ALL,
+};
+
 int btrfs_check_data_free_space(struct inode *inode, u64 bytes);
 void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes);
 void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
@@ -2874,24 +3041,19 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes);
 void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes);
 int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes);
 void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes);
-void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv);
-struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root);
+void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type);
+struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
+                                              unsigned short type);
 void btrfs_free_block_rsv(struct btrfs_root *root,
                           struct btrfs_block_rsv *rsv);
 int btrfs_block_rsv_add(struct btrfs_root *root,
-                        struct btrfs_block_rsv *block_rsv,
-                        u64 num_bytes);
-int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
-                                struct btrfs_block_rsv *block_rsv,
-                                u64 num_bytes);
+                        struct btrfs_block_rsv *block_rsv, u64 num_bytes,
+                        enum btrfs_reserve_flush_enum flush);
 int btrfs_block_rsv_check(struct btrfs_root *root,
                           struct btrfs_block_rsv *block_rsv, int min_factor);
 int btrfs_block_rsv_refill(struct btrfs_root *root,
-                          struct btrfs_block_rsv *block_rsv,
-                          u64 min_reserved);
-int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
-                                   struct btrfs_block_rsv *block_rsv,
-                                   u64 min_reserved);
+                           struct btrfs_block_rsv *block_rsv, u64 min_reserved,
+                           enum btrfs_reserve_flush_enum flush);
 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
                             struct btrfs_block_rsv *dst_rsv,
                             u64 num_bytes);
@@ -2915,6 +3077,7 @@ int btrfs_trim_fs(struct btrfs_root *root, struct fstrim_range *range);
 int btrfs_init_space_info(struct btrfs_fs_info *fs_info);
 int btrfs_delayed_refs_qgroup_accounting(struct btrfs_trans_handle *trans,
                                          struct btrfs_fs_info *fs_info);
+int __get_raid_index(u64 flags);
 /* ctree.c */
 int btrfs_bin_search(struct extent_buffer *eb, struct btrfs_key *key,
                      int level, int *slot);
@@ -3025,6 +3188,9 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
 }
 
 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
+int btrfs_next_leaf_write(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root, struct btrfs_path *path,
+                          int del);
 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
                         u64 time_seq);
 static inline int btrfs_next_old_item(struct btrfs_root *root,
@@ -3080,6 +3246,7 @@ static inline u64 btrfs_inc_tree_mod_seq(struct btrfs_fs_info *fs_info)
 {
         return atomic_inc_return(&fs_info->tree_mod_seq);
 }
+int btrfs_old_root_level(struct btrfs_root *root, u64 time_seq);
 
 /* root-item.c */
 int btrfs_find_root_ref(struct btrfs_root *tree_root,
@@ -3116,6 +3283,8 @@ void btrfs_update_root_times(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root);
 
 /* dir-item.c */
+int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
+                          const char *name, int name_len);
 int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,
                           struct btrfs_root *root, const char *name,
                           int name_len, struct inode *dir,
@@ -3172,12 +3341,12 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            const char *name, int name_len,
                            u64 inode_objectid, u64 ref_objectid, u64 *index);
-struct btrfs_inode_ref *
-btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root,
-                        struct btrfs_path *path,
-                        const char *name, int name_len,
-                        u64 inode_objectid, u64 ref_objectid, int mod);
+int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
+                              struct btrfs_root *root,
+                              struct btrfs_path *path,
+                              const char *name, int name_len,
+                              u64 inode_objectid, u64 ref_objectid, int mod,
+                              u64 *ret_index);
 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
                              struct btrfs_path *path, u64 objectid);
@@ -3185,6 +3354,19 @@ int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
                        *root, struct btrfs_path *path,
                        struct btrfs_key *location, int mod);
 
+struct btrfs_inode_extref *
+btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root,
+                          struct btrfs_path *path,
+                          const char *name, int name_len,
+                          u64 inode_objectid, u64 ref_objectid, int ins_len,
+                          int cow);
+
+int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
+                                   u64 ref_objectid, const char *name,
+                                   int name_len,
+                                   struct btrfs_inode_extref **extref_ret);
+
 /* file-item.c */
 int btrfs_del_csums(struct btrfs_trans_handle *trans,
                     struct btrfs_root *root, u64 bytenr, u64 len);
@@ -3202,6 +3384,7 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
                              struct btrfs_path *path, u64 objectid,
                              u64 bytenr, int mod);
+u64 btrfs_file_extent_length(struct btrfs_path *path);
 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            struct btrfs_ordered_sum *sums);
@@ -3217,6 +3400,19 @@ int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
                              struct list_head *list, int search_commit);
 /* inode.c */
+struct btrfs_delalloc_work {
+        struct inode *inode;
+        int wait;
+        int delay_iput;
+        struct completion completion;
+        struct list_head list;
+        struct btrfs_work work;
+};
+
+struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
+                                                    int wait, int delay_iput);
+void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work);
+
 struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
                                            size_t pg_offset, u64 start, u64 len,
                                            int create);
@@ -3249,6 +3445,8 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root,
                         struct inode *dir, u64 objectid,
                         const char *name, int name_len);
+int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
+                        int front);
 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root,
                                struct inode *inode, u64 new_size,
@@ -3283,6 +3481,8 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
 int btrfs_update_inode(struct btrfs_trans_handle *trans,
                               struct btrfs_root *root,
                               struct inode *inode);
+int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root, struct inode *inode);
 int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode);
 int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
 int btrfs_orphan_cleanup(struct btrfs_root *root);
@@ -3308,16 +3508,30 @@ void btrfs_inherit_iflags(struct inode *inode, struct inode *dir);
 int btrfs_defrag_file(struct inode *inode, struct file *file,
                       struct btrfs_ioctl_defrag_range_args *range,
                       u64 newer_than, unsigned long max_pages);
+void btrfs_get_block_group_info(struct list_head *groups_list,
+                                struct btrfs_ioctl_space_info *space);
+
 /* file.c */
+int btrfs_auto_defrag_init(void);
+void btrfs_auto_defrag_exit(void);
 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
                            struct inode *inode);
 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info);
+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);
-int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
-                            int skip_pinned);
+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 inode *inode,
-                       u64 start, u64 end, u64 *hint_byte, int drop_cache);
+int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                         struct btrfs_root *root, struct inode *inode,
+                         struct btrfs_path *path, u64 start, u64 end,
+                         u64 *drop_end, int drop_cache);
+int btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root, struct inode *inode, u64 start,
+                       u64 end, int drop_cache);
 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
                               struct inode *inode, u64 start, u64 end);
 int btrfs_release_file(struct inode *inode, struct file *file);
@@ -3378,6 +3592,11 @@ static inline void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info,
         }
 }
 
+/*
+ * Call btrfs_abort_transaction as early as possible when an error condition is
+ * detected, that way the exact line number is reported.
+ */
+
 #define btrfs_abort_transaction(trans, root, errno)             \
 do {                                                            \
         __btrfs_abort_transaction(trans, root, __func__,        \
@@ -3445,15 +3664,16 @@ int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans,
                               struct btrfs_pending_snapshot *pending);
 
 /* scrub.c */
-int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
-                    struct btrfs_scrub_progress *progress, int readonly);
+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(struct btrfs_root *root);
-int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev);
+int btrfs_scrub_cancel(struct btrfs_fs_info *info);
+int btrfs_scrub_cancel_dev(struct btrfs_fs_info *info,
+                           struct btrfs_device *dev);
 int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid);
 int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
                          struct btrfs_scrub_progress *progress);
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 52c85e2b95d0..34836036f01b 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -29,7 +29,7 @@ static struct kmem_cache *delayed_node_cache;
 
 int __init btrfs_delayed_inode_init(void)
 {
-        delayed_node_cache = kmem_cache_create("delayed_node",
+        delayed_node_cache = kmem_cache_create("btrfs_delayed_node",
                                         sizeof(struct btrfs_delayed_node),
                                         0,
                                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
@@ -650,8 +650,9 @@ static int btrfs_delayed_inode_reserve_metadata(
          * we're accounted for.
          */
         if (!src_rsv || (!trans->bytes_reserved &&
-            src_rsv != &root->fs_info->delalloc_block_rsv)) {
-                ret = btrfs_block_rsv_add_noflush(root, dst_rsv, num_bytes);
+                         src_rsv->type != BTRFS_BLOCK_RSV_DELALLOC)) {
+                ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes,
+                                          BTRFS_RESERVE_NO_FLUSH);
                 /*
                  * Since we're under a transaction reserve_metadata_bytes could
                  * try to commit the transaction which will make it return
@@ -668,7 +669,7 @@ static int btrfs_delayed_inode_reserve_metadata(
                                                       num_bytes, 1);
                 }
                 return ret;
-        } else if (src_rsv == &root->fs_info->delalloc_block_rsv) {
+        } else if (src_rsv->type == BTRFS_BLOCK_RSV_DELALLOC) {
                 spin_lock(&BTRFS_I(inode)->lock);
                 if (test_and_clear_bit(BTRFS_INODE_DELALLOC_META_RESERVED,
                                        &BTRFS_I(inode)->runtime_flags)) {
@@ -686,7 +687,8 @@ static int btrfs_delayed_inode_reserve_metadata(
                  * reserve something strictly for us.  If not be a pain and try
                  * to steal from the delalloc block rsv.
                  */
-                ret = btrfs_block_rsv_add_noflush(root, dst_rsv, num_bytes);
+                ret = btrfs_block_rsv_add(root, dst_rsv, num_bytes,
+                                          BTRFS_RESERVE_NO_FLUSH);
                 if (!ret)
                         goto out;
 
@@ -1255,7 +1257,6 @@ static void btrfs_async_run_delayed_node_done(struct btrfs_work *work)
         struct btrfs_delayed_node *delayed_node = NULL;
         struct btrfs_root *root;
         struct btrfs_block_rsv *block_rsv;
-        unsigned long nr = 0;
         int need_requeue = 0;
         int ret;
 
@@ -1316,11 +1317,9 @@ static void btrfs_async_run_delayed_node_done(struct btrfs_work *work)
                                            delayed_node);
         mutex_unlock(&delayed_node->mutex);
 
-        nr = trans->blocks_used;
-
         trans->block_rsv = block_rsv;
         btrfs_end_transaction_dmeta(trans, root);
-        __btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty_nodelay(root);
 free_path:
         btrfs_free_path(path);
 out:
diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
new file mode 100644
index 000000000000..66dbc8dbddf7
--- /dev/null
+++ b/fs/btrfs/dev-replace.c
@@ -0,0 +1,856 @@
+/*
+ * Copyright (C) STRATO AG 2012.  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/sched.h>
+#include <linux/bio.h>
+#include <linux/slab.h>
+#include <linux/buffer_head.h>
+#include <linux/blkdev.h>
+#include <linux/random.h>
+#include <linux/iocontext.h>
+#include <linux/capability.h>
+#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"
+#include "transaction.h"
+#include "print-tree.h"
+#include "volumes.h"
+#include "async-thread.h"
+#include "check-integrity.h"
+#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(
+                                                struct btrfs_fs_info *fs_info,
+                                                struct btrfs_device *srcdev,
+                                                struct btrfs_device *tgtdev);
+static int btrfs_dev_replace_find_srcdev(struct btrfs_root *root, u64 srcdevid,
+                                         char *srcdev_name,
+                                         struct btrfs_device **device);
+static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info);
+static int btrfs_dev_replace_kthread(void *data);
+static int btrfs_dev_replace_continue_on_mount(struct btrfs_fs_info *fs_info);
+
+
+int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_key key;
+        struct btrfs_root *dev_root = fs_info->dev_root;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        struct extent_buffer *eb;
+        int slot;
+        int ret = 0;
+        struct btrfs_path *path = NULL;
+        int item_size;
+        struct btrfs_dev_replace_item *ptr;
+        u64 src_devid;
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        key.objectid = 0;
+        key.type = BTRFS_DEV_REPLACE_KEY;
+        key.offset = 0;
+        ret = btrfs_search_slot(NULL, dev_root, &key, path, 0, 0);
+        if (ret) {
+no_valid_dev_replace_entry_found:
+                ret = 0;
+                dev_replace->replace_state =
+                        BTRFS_DEV_REPLACE_ITEM_STATE_NEVER_STARTED;
+                dev_replace->cont_reading_from_srcdev_mode =
+                    BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS;
+                dev_replace->replace_state = 0;
+                dev_replace->time_started = 0;
+                dev_replace->time_stopped = 0;
+                atomic64_set(&dev_replace->num_write_errors, 0);
+                atomic64_set(&dev_replace->num_uncorrectable_read_errors, 0);
+                dev_replace->cursor_left = 0;
+                dev_replace->committed_cursor_left = 0;
+                dev_replace->cursor_left_last_write_of_item = 0;
+                dev_replace->cursor_right = 0;
+                dev_replace->srcdev = NULL;
+                dev_replace->tgtdev = NULL;
+                dev_replace->is_valid = 0;
+                dev_replace->item_needs_writeback = 0;
+                goto out;
+        }
+        slot = path->slots[0];
+        eb = path->nodes[0];
+        item_size = btrfs_item_size_nr(eb, slot);
+        ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_replace_item);
+
+        if (item_size != sizeof(struct btrfs_dev_replace_item)) {
+                pr_warn("btrfs: dev_replace entry found has unexpected size, ignore entry\n");
+                goto no_valid_dev_replace_entry_found;
+        }
+
+        src_devid = btrfs_dev_replace_src_devid(eb, ptr);
+        dev_replace->cont_reading_from_srcdev_mode =
+                btrfs_dev_replace_cont_reading_from_srcdev_mode(eb, ptr);
+        dev_replace->replace_state = btrfs_dev_replace_replace_state(eb, ptr);
+        dev_replace->time_started = btrfs_dev_replace_time_started(eb, ptr);
+        dev_replace->time_stopped =
+                btrfs_dev_replace_time_stopped(eb, ptr);
+        atomic64_set(&dev_replace->num_write_errors,
+                     btrfs_dev_replace_num_write_errors(eb, ptr));
+        atomic64_set(&dev_replace->num_uncorrectable_read_errors,
+                     btrfs_dev_replace_num_uncorrectable_read_errors(eb, ptr));
+        dev_replace->cursor_left = btrfs_dev_replace_cursor_left(eb, ptr);
+        dev_replace->committed_cursor_left = dev_replace->cursor_left;
+        dev_replace->cursor_left_last_write_of_item = dev_replace->cursor_left;
+        dev_replace->cursor_right = btrfs_dev_replace_cursor_right(eb, ptr);
+        dev_replace->is_valid = 1;
+
+        dev_replace->item_needs_writeback = 0;
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                dev_replace->srcdev = NULL;
+                dev_replace->tgtdev = NULL;
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                dev_replace->srcdev = btrfs_find_device(fs_info, src_devid,
+                                                        NULL, NULL);
+                dev_replace->tgtdev = btrfs_find_device(fs_info,
+                                                        BTRFS_DEV_REPLACE_DEVID,
+                                                        NULL, NULL);
+                /*
+                 * allow 'btrfs dev replace_cancel' if src/tgt device is
+                 * missing
+                 */
+                if (!dev_replace->srcdev &&
+                    !btrfs_test_opt(dev_root, DEGRADED)) {
+                        ret = -EIO;
+                        pr_warn("btrfs: cannot mount because device replace operation is ongoing and\n" "srcdev (devid %llu) is missing, need to run 'btrfs dev scan'?\n",
+                                (unsigned long long)src_devid);
+                }
+                if (!dev_replace->tgtdev &&
+                    !btrfs_test_opt(dev_root, DEGRADED)) {
+                        ret = -EIO;
+                        pr_warn("btrfs: cannot mount because device replace operation is ongoing and\n" "tgtdev (devid %llu) is missing, need to run btrfs dev scan?\n",
+                                (unsigned long long)BTRFS_DEV_REPLACE_DEVID);
+                }
+                if (dev_replace->tgtdev) {
+                        if (dev_replace->srcdev) {
+                                dev_replace->tgtdev->total_bytes =
+                                        dev_replace->srcdev->total_bytes;
+                                dev_replace->tgtdev->disk_total_bytes =
+                                        dev_replace->srcdev->disk_total_bytes;
+                                dev_replace->tgtdev->bytes_used =
+                                        dev_replace->srcdev->bytes_used;
+                        }
+                        dev_replace->tgtdev->is_tgtdev_for_dev_replace = 1;
+                        btrfs_init_dev_replace_tgtdev_for_resume(fs_info,
+                                dev_replace->tgtdev);
+                }
+                break;
+        }
+
+out:
+        if (path)
+                btrfs_free_path(path);
+        return ret;
+}
+
+/*
+ * called from commit_transaction. Writes changed device replace state to
+ * disk.
+ */
+int btrfs_run_dev_replace(struct btrfs_trans_handle *trans,
+                          struct btrfs_fs_info *fs_info)
+{
+        int ret;
+        struct btrfs_root *dev_root = fs_info->dev_root;
+        struct btrfs_path *path;
+        struct btrfs_key key;
+        struct extent_buffer *eb;
+        struct btrfs_dev_replace_item *ptr;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+
+        btrfs_dev_replace_lock(dev_replace);
+        if (!dev_replace->is_valid ||
+            !dev_replace->item_needs_writeback) {
+                btrfs_dev_replace_unlock(dev_replace);
+                return 0;
+        }
+        btrfs_dev_replace_unlock(dev_replace);
+
+        key.objectid = 0;
+        key.type = BTRFS_DEV_REPLACE_KEY;
+        key.offset = 0;
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ret = btrfs_search_slot(trans, dev_root, &key, path, -1, 1);
+        if (ret < 0) {
+                pr_warn("btrfs: error %d while searching for dev_replace item!\n",
+                        ret);
+                goto out;
+        }
+
+        if (ret == 0 &&
+            btrfs_item_size_nr(path->nodes[0], path->slots[0]) < sizeof(*ptr)) {
+                /*
+                 * need to delete old one and insert a new one.
+                 * Since no attempt is made to recover any old state, if the
+                 * dev_replace state is 'running', the data on the target
+                 * drive is lost.
+                 * It would be possible to recover the state: just make sure
+                 * that the beginning of the item is never changed and always
+                 * contains all the essential information. Then read this
+                 * minimal set of information and use it as a base for the
+                 * new state.
+                 */
+                ret = btrfs_del_item(trans, dev_root, path);
+                if (ret != 0) {
+                        pr_warn("btrfs: delete too small dev_replace item failed %d!\n",
+                                ret);
+                        goto out;
+                }
+                ret = 1;
+        }
+
+        if (ret == 1) {
+                /* need to insert a new item */
+                btrfs_release_path(path);
+                ret = btrfs_insert_empty_item(trans, dev_root, path,
+                                              &key, sizeof(*ptr));
+                if (ret < 0) {
+                        pr_warn("btrfs: insert dev_replace item failed %d!\n",
+                                ret);
+                        goto out;
+                }
+        }
+
+        eb = path->nodes[0];
+        ptr = btrfs_item_ptr(eb, path->slots[0],
+                             struct btrfs_dev_replace_item);
+
+        btrfs_dev_replace_lock(dev_replace);
+        if (dev_replace->srcdev)
+                btrfs_set_dev_replace_src_devid(eb, ptr,
+                        dev_replace->srcdev->devid);
+        else
+                btrfs_set_dev_replace_src_devid(eb, ptr, (u64)-1);
+        btrfs_set_dev_replace_cont_reading_from_srcdev_mode(eb, ptr,
+                dev_replace->cont_reading_from_srcdev_mode);
+        btrfs_set_dev_replace_replace_state(eb, ptr,
+                dev_replace->replace_state);
+        btrfs_set_dev_replace_time_started(eb, ptr, dev_replace->time_started);
+        btrfs_set_dev_replace_time_stopped(eb, ptr, dev_replace->time_stopped);
+        btrfs_set_dev_replace_num_write_errors(eb, ptr,
+                atomic64_read(&dev_replace->num_write_errors));
+        btrfs_set_dev_replace_num_uncorrectable_read_errors(eb, ptr,
+                atomic64_read(&dev_replace->num_uncorrectable_read_errors));
+        dev_replace->cursor_left_last_write_of_item =
+                dev_replace->cursor_left;
+        btrfs_set_dev_replace_cursor_left(eb, ptr,
+                dev_replace->cursor_left_last_write_of_item);
+        btrfs_set_dev_replace_cursor_right(eb, ptr,
+                dev_replace->cursor_right);
+        dev_replace->item_needs_writeback = 0;
+        btrfs_dev_replace_unlock(dev_replace);
+
+        btrfs_mark_buffer_dirty(eb);
+
+out:
+        btrfs_free_path(path);
+
+        return ret;
+}
+
+void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+
+        dev_replace->committed_cursor_left =
+                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)
+{
+        struct btrfs_trans_handle *trans;
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        int ret;
+        struct btrfs_device *tgt_device = NULL;
+        struct btrfs_device *src_device = NULL;
+
+        switch (args->start.cont_reading_from_srcdev_mode) {
+        case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS:
+        case BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if ((args->start.srcdevid == 0 && args->start.srcdev_name[0] == '\0') ||
+            args->start.tgtdev_name[0] == '\0')
+                return -EINVAL;
+
+        mutex_lock(&fs_info->volume_mutex);
+        ret = btrfs_init_dev_replace_tgtdev(root, args->start.tgtdev_name,
+                                            &tgt_device);
+        if (ret) {
+                pr_err("btrfs: target device %s is invalid!\n",
+                       args->start.tgtdev_name);
+                mutex_unlock(&fs_info->volume_mutex);
+                return -EINVAL;
+        }
+
+        ret = btrfs_dev_replace_find_srcdev(root, args->start.srcdevid,
+                                            args->start.srcdev_name,
+                                            &src_device);
+        mutex_unlock(&fs_info->volume_mutex);
+        if (ret) {
+                ret = -EINVAL;
+                goto leave_no_lock;
+        }
+
+        if (tgt_device->total_bytes < src_device->total_bytes) {
+                pr_err("btrfs: target device is smaller than source device!\n");
+                ret = -EINVAL;
+                goto leave_no_lock;
+        }
+
+        btrfs_dev_replace_lock(dev_replace);
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED;
+                goto leave;
+        }
+
+        dev_replace->cont_reading_from_srcdev_mode =
+                args->start.cont_reading_from_srcdev_mode;
+        WARN_ON(!src_device);
+        dev_replace->srcdev = src_device;
+        WARN_ON(!tgt_device);
+        dev_replace->tgtdev = tgt_device;
+
+        printk_in_rcu(KERN_INFO
+                      "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,
+                      rcu_str_deref(tgt_device->name));
+
+        tgt_device->total_bytes = src_device->total_bytes;
+        tgt_device->disk_total_bytes = src_device->disk_total_bytes;
+        tgt_device->bytes_used = src_device->bytes_used;
+
+        /*
+         * from now on, the writes to the srcdev are all duplicated to
+         * 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->cursor_left = 0;
+        dev_replace->committed_cursor_left = 0;
+        dev_replace->cursor_left_last_write_of_item = 0;
+        dev_replace->cursor_right = 0;
+        dev_replace->is_valid = 1;
+        dev_replace->item_needs_writeback = 1;
+        args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
+        btrfs_dev_replace_unlock(dev_replace);
+
+        btrfs_wait_ordered_extents(root, 0);
+
+        /* force writing the updated state information to disk */
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                btrfs_dev_replace_lock(dev_replace);
+                goto leave;
+        }
+
+        ret = btrfs_commit_transaction(trans, root);
+        WARN_ON(ret);
+
+        /* the disk copy procedure reuses the scrub code */
+        ret = btrfs_scrub_dev(fs_info, src_device->devid, 0,
+                              src_device->total_bytes,
+                              &dev_replace->scrub_progress, 0, 1);
+
+        ret = btrfs_dev_replace_finishing(root->fs_info, ret);
+        WARN_ON(ret);
+
+        return 0;
+
+leave:
+        dev_replace->srcdev = NULL;
+        dev_replace->tgtdev = NULL;
+        btrfs_dev_replace_unlock(dev_replace);
+leave_no_lock:
+        if (tgt_device)
+                btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
+        return ret;
+}
+
+static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
+                                       int scrub_ret)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        struct btrfs_device *tgt_device;
+        struct btrfs_device *src_device;
+        struct btrfs_root *root = fs_info->tree_root;
+        u8 uuid_tmp[BTRFS_UUID_SIZE];
+        struct btrfs_trans_handle *trans;
+        int ret = 0;
+
+        /* don't allow cancel or unmount to disturb the finishing procedure */
+        mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
+
+        btrfs_dev_replace_lock(dev_replace);
+        /* was the operation canceled, or is it finished? */
+        if (dev_replace->replace_state !=
+            BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED) {
+                btrfs_dev_replace_unlock(dev_replace);
+                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+                return 0;
+        }
+
+        tgt_device = dev_replace->tgtdev;
+        src_device = dev_replace->srcdev;
+        btrfs_dev_replace_unlock(dev_replace);
+
+        /* replace old device with new one in mapping tree */
+        if (!scrub_ret)
+                btrfs_dev_replace_update_device_in_mapping_tree(fs_info,
+                                                                src_device,
+                                                                tgt_device);
+
+        /*
+         * flush all outstanding I/O and inode extent mappings before the
+         * copy operation is declared as being finished
+         */
+        btrfs_start_delalloc_inodes(root, 0);
+        btrfs_wait_ordered_extents(root, 0);
+
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+                return PTR_ERR(trans);
+        }
+        ret = btrfs_commit_transaction(trans, root);
+        WARN_ON(ret);
+
+        /* keep away write_all_supers() during the finishing procedure */
+        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
+        btrfs_dev_replace_lock(dev_replace);
+        dev_replace->replace_state =
+                scrub_ret ? BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED
+                          : 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->item_needs_writeback = 1;
+
+        if (scrub_ret) {
+                printk_in_rcu(KERN_ERR
+                              "btrfs: btrfs_scrub_dev(%s, %llu, %s) failed %d\n",
+                              src_device->missing ? "<missing disk>" :
+                                rcu_str_deref(src_device->name),
+                              src_device->devid,
+                              rcu_str_deref(tgt_device->name), scrub_ret);
+                btrfs_dev_replace_unlock(dev_replace);
+                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
+                if (tgt_device)
+                        btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
+                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+
+                return 0;
+        }
+
+        printk_in_rcu(KERN_INFO
+                      "btrfs: dev_replace from %s (devid %llu) to %s) finished\n",
+                      src_device->missing ? "<missing disk>" :
+                        rcu_str_deref(src_device->name),
+                      src_device->devid,
+                      rcu_str_deref(tgt_device->name));
+        tgt_device->is_tgtdev_for_dev_replace = 0;
+        tgt_device->devid = src_device->devid;
+        src_device->devid = BTRFS_DEV_REPLACE_DEVID;
+        tgt_device->bytes_used = src_device->bytes_used;
+        memcpy(uuid_tmp, tgt_device->uuid, sizeof(uuid_tmp));
+        memcpy(tgt_device->uuid, src_device->uuid, sizeof(tgt_device->uuid));
+        memcpy(src_device->uuid, uuid_tmp, sizeof(src_device->uuid));
+        tgt_device->total_bytes = src_device->total_bytes;
+        tgt_device->disk_total_bytes = src_device->disk_total_bytes;
+        tgt_device->bytes_used = src_device->bytes_used;
+        if (fs_info->sb->s_bdev == src_device->bdev)
+                fs_info->sb->s_bdev = tgt_device->bdev;
+        if (fs_info->fs_devices->latest_bdev == src_device->bdev)
+                fs_info->fs_devices->latest_bdev = tgt_device->bdev;
+        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
+         * source device is not part of the filesystem anymore and its 1st
+         * superblock is scratched out so that it is no longer marked to
+         * belong to this filesystem.
+         */
+        btrfs_dev_replace_unlock(dev_replace);
+        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
+
+        /* write back the superblocks */
+        trans = btrfs_start_transaction(root, 0);
+        if (!IS_ERR(trans))
+                btrfs_commit_transaction(trans, root);
+
+        mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+
+        return 0;
+}
+
+static void btrfs_dev_replace_update_device_in_mapping_tree(
+                                                struct btrfs_fs_info *fs_info,
+                                                struct btrfs_device *srcdev,
+                                                struct btrfs_device *tgtdev)
+{
+        struct extent_map_tree *em_tree = &fs_info->mapping_tree.map_tree;
+        struct extent_map *em;
+        struct map_lookup *map;
+        u64 start = 0;
+        int i;
+
+        write_lock(&em_tree->lock);
+        do {
+                em = lookup_extent_mapping(em_tree, start, (u64)-1);
+                if (!em)
+                        break;
+                map = (struct map_lookup *)em->bdev;
+                for (i = 0; i < map->num_stripes; i++)
+                        if (srcdev == map->stripes[i].dev)
+                                map->stripes[i].dev = tgtdev;
+                start = em->start + em->len;
+                free_extent_map(em);
+        } while (start);
+        write_unlock(&em_tree->lock);
+}
+
+static int btrfs_dev_replace_find_srcdev(struct btrfs_root *root, u64 srcdevid,
+                                         char *srcdev_name,
+                                         struct btrfs_device **device)
+{
+        int ret;
+
+        if (srcdevid) {
+                ret = 0;
+                *device = btrfs_find_device(root->fs_info, srcdevid, NULL,
+                                            NULL);
+                if (!*device)
+                        ret = -ENOENT;
+        } else {
+                ret = btrfs_find_device_missing_or_by_path(root, srcdev_name,
+                                                           device);
+        }
+        return ret;
+}
+
+void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
+                              struct btrfs_ioctl_dev_replace_args *args)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+
+        btrfs_dev_replace_lock(dev_replace);
+        /* even if !dev_replace_is_valid, the values are good enough for
+         * the replace_status ioctl */
+        args->result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
+        args->status.replace_state = dev_replace->replace_state;
+        args->status.time_started = dev_replace->time_started;
+        args->status.time_stopped = dev_replace->time_stopped;
+        args->status.num_write_errors =
+                atomic64_read(&dev_replace->num_write_errors);
+        args->status.num_uncorrectable_read_errors =
+                atomic64_read(&dev_replace->num_uncorrectable_read_errors);
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                args->status.progress_1000 = 0;
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+                args->status.progress_1000 = 1000;
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                args->status.progress_1000 = div64_u64(dev_replace->cursor_left,
+                        div64_u64(dev_replace->srcdev->total_bytes, 1000));
+                break;
+        }
+        btrfs_dev_replace_unlock(dev_replace);
+}
+
+int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info,
+                             struct btrfs_ioctl_dev_replace_args *args)
+{
+        args->result = __btrfs_dev_replace_cancel(fs_info);
+        return 0;
+}
+
+static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        struct btrfs_device *tgt_device = NULL;
+        struct btrfs_trans_handle *trans;
+        struct btrfs_root *root = fs_info->tree_root;
+        u64 result;
+        int ret;
+
+        mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
+        btrfs_dev_replace_lock(dev_replace);
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED;
+                btrfs_dev_replace_unlock(dev_replace);
+                goto leave;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                result = BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR;
+                tgt_device = dev_replace->tgtdev;
+                dev_replace->tgtdev = NULL;
+                dev_replace->srcdev = NULL;
+                break;
+        }
+        dev_replace->replace_state = BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED;
+        dev_replace->time_stopped = btrfs_get_seconds_since_1970();
+        dev_replace->item_needs_writeback = 1;
+        btrfs_dev_replace_unlock(dev_replace);
+        btrfs_scrub_cancel(fs_info);
+
+        trans = btrfs_start_transaction(root, 0);
+        if (IS_ERR(trans)) {
+                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+                return PTR_ERR(trans);
+        }
+        ret = btrfs_commit_transaction(trans, root);
+        WARN_ON(ret);
+        if (tgt_device)
+                btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);
+
+leave:
+        mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+        return result;
+}
+
+void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+
+        mutex_lock(&dev_replace->lock_finishing_cancel_unmount);
+        btrfs_dev_replace_lock(dev_replace);
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                break;
+        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->item_needs_writeback = 1;
+                pr_info("btrfs: suspending dev_replace for unmount\n");
+                break;
+        }
+
+        btrfs_dev_replace_unlock(dev_replace);
+        mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
+}
+
+/* resume dev_replace procedure that was interrupted by unmount */
+int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info)
+{
+        struct task_struct *task;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+
+        btrfs_dev_replace_lock(dev_replace);
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                btrfs_dev_replace_unlock(dev_replace);
+                return 0;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                dev_replace->replace_state =
+                        BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED;
+                break;
+        }
+        if (!dev_replace->tgtdev || !dev_replace->tgtdev->bdev) {
+                pr_info("btrfs: cannot continue dev_replace, tgtdev is missing\n"
+                        "btrfs: you may cancel the operation after 'mount -o degraded'\n");
+                btrfs_dev_replace_unlock(dev_replace);
+                return 0;
+        }
+        btrfs_dev_replace_unlock(dev_replace);
+
+        WARN_ON(atomic_xchg(
+                &fs_info->mutually_exclusive_operation_running, 1));
+        task = kthread_run(btrfs_dev_replace_kthread, fs_info, "btrfs-devrepl");
+        return PTR_RET(task);
+}
+
+static int btrfs_dev_replace_kthread(void *data)
+{
+        struct btrfs_fs_info *fs_info = data;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        struct btrfs_ioctl_dev_replace_args *status_args;
+        u64 progress;
+
+        status_args = kzalloc(sizeof(*status_args), GFP_NOFS);
+        if (status_args) {
+                btrfs_dev_replace_status(fs_info, status_args);
+                progress = status_args->status.progress_1000;
+                kfree(status_args);
+                do_div(progress, 10);
+                printk_in_rcu(KERN_INFO
+                              "btrfs: continuing dev_replace from %s (devid %llu) to %s @%u%%\n",
+                              dev_replace->srcdev->missing ? "<missing disk>" :
+                                rcu_str_deref(dev_replace->srcdev->name),
+                              dev_replace->srcdev->devid,
+                              dev_replace->tgtdev ?
+                                rcu_str_deref(dev_replace->tgtdev->name) :
+                                "<missing target disk>",
+                              (unsigned int)progress);
+        }
+        btrfs_dev_replace_continue_on_mount(fs_info);
+        atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
+
+        return 0;
+}
+
+static int btrfs_dev_replace_continue_on_mount(struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        int ret;
+
+        ret = btrfs_scrub_dev(fs_info, dev_replace->srcdev->devid,
+                              dev_replace->committed_cursor_left,
+                              dev_replace->srcdev->total_bytes,
+                              &dev_replace->scrub_progress, 0, 1);
+        ret = btrfs_dev_replace_finishing(fs_info, ret);
+        WARN_ON(ret);
+        return 0;
+}
+
+int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace)
+{
+        if (!dev_replace->is_valid)
+                return 0;
+
+        switch (dev_replace->replace_state) {
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED:
+                return 0;
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED:
+        case BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED:
+                /*
+                 * return true even if tgtdev is missing (this is
+                 * something that can happen if the dev_replace
+                 * procedure is suspended by an umount and then
+                 * the tgtdev is missing (or "btrfs dev scan") was
+                 * not called and the the filesystem is remounted
+                 * in degraded state. This does not stop the
+                 * dev_replace procedure. It needs to be canceled
+                 * manually if the cancelation is wanted.
+                 */
+                break;
+        }
+        return 1;
+}
+
+void btrfs_dev_replace_lock(struct btrfs_dev_replace *dev_replace)
+{
+        /* the beginning is just an optimization for the typical case */
+        if (atomic_read(&dev_replace->nesting_level) == 0) {
+acquire_lock:
+                /* this is not a nested case where the same thread
+                 * is trying to acqurire the same lock twice */
+                mutex_lock(&dev_replace->lock);
+                mutex_lock(&dev_replace->lock_management_lock);
+                dev_replace->lock_owner = current->pid;
+                atomic_inc(&dev_replace->nesting_level);
+                mutex_unlock(&dev_replace->lock_management_lock);
+                return;
+        }
+
+        mutex_lock(&dev_replace->lock_management_lock);
+        if (atomic_read(&dev_replace->nesting_level) > 0 &&
+            dev_replace->lock_owner == current->pid) {
+                WARN_ON(!mutex_is_locked(&dev_replace->lock));
+                atomic_inc(&dev_replace->nesting_level);
+                mutex_unlock(&dev_replace->lock_management_lock);
+                return;
+        }
+
+        mutex_unlock(&dev_replace->lock_management_lock);
+        goto acquire_lock;
+}
+
+void btrfs_dev_replace_unlock(struct btrfs_dev_replace *dev_replace)
+{
+        WARN_ON(!mutex_is_locked(&dev_replace->lock));
+        mutex_lock(&dev_replace->lock_management_lock);
+        WARN_ON(atomic_read(&dev_replace->nesting_level) < 1);
+        WARN_ON(dev_replace->lock_owner != current->pid);
+        atomic_dec(&dev_replace->nesting_level);
+        if (atomic_read(&dev_replace->nesting_level) == 0) {
+                dev_replace->lock_owner = 0;
+                mutex_unlock(&dev_replace->lock_management_lock);
+                mutex_unlock(&dev_replace->lock);
+        } else {
+                mutex_unlock(&dev_replace->lock_management_lock);
+        }
+}
diff --git a/fs/btrfs/dev-replace.h b/fs/btrfs/dev-replace.h
new file mode 100644
index 000000000000..20035cbbf021
--- /dev/null
+++ b/fs/btrfs/dev-replace.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) STRATO AG 2012.  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.
+ */
+
+#if !defined(__BTRFS_DEV_REPLACE__)
+#define __BTRFS_DEV_REPLACE__
+
+struct btrfs_ioctl_dev_replace_args;
+
+int btrfs_init_dev_replace(struct btrfs_fs_info *fs_info);
+int btrfs_run_dev_replace(struct btrfs_trans_handle *trans,
+                          struct btrfs_fs_info *fs_info);
+void btrfs_after_dev_replace_commit(struct btrfs_fs_info *fs_info);
+int btrfs_dev_replace_start(struct btrfs_root *root,
+                            struct btrfs_ioctl_dev_replace_args *args);
+void btrfs_dev_replace_status(struct btrfs_fs_info *fs_info,
+                              struct btrfs_ioctl_dev_replace_args *args);
+int btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info,
+                             struct btrfs_ioctl_dev_replace_args *args);
+void btrfs_dev_replace_suspend_for_unmount(struct btrfs_fs_info *fs_info);
+int btrfs_resume_dev_replace_async(struct btrfs_fs_info *fs_info);
+int btrfs_dev_replace_is_ongoing(struct btrfs_dev_replace *dev_replace);
+void btrfs_dev_replace_lock(struct btrfs_dev_replace *dev_replace);
+void btrfs_dev_replace_unlock(struct btrfs_dev_replace *dev_replace);
+
+static inline void btrfs_dev_replace_stats_inc(atomic64_t *stat_value)
+{
+        atomic64_inc(stat_value);
+}
+#endif
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index c1a074d0696f..502c2158167c 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -213,6 +213,65 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
         return btrfs_match_dir_item_name(root, path, name, name_len);
 }
 
+int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,
+                                   const char *name, int name_len)
+{
+        int ret;
+        struct btrfs_key key;
+        struct btrfs_dir_item *di;
+        int data_size;
+        struct extent_buffer *leaf;
+        int slot;
+        struct btrfs_path *path;
+
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        key.objectid = dir;
+        btrfs_set_key_type(&key, BTRFS_DIR_ITEM_KEY);
+        key.offset = btrfs_name_hash(name, name_len);
+
+        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
+
+        /* return back any errors */
+        if (ret < 0)
+                goto out;
+
+        /* nothing found, we're safe */
+        if (ret > 0) {
+                ret = 0;
+                goto out;
+        }
+
+        /* we found an item, look for our name in the item */
+        di = btrfs_match_dir_item_name(root, path, name, name_len);
+        if (di) {
+                /* our exact name was found */
+                ret = -EEXIST;
+                goto out;
+        }
+
+        /*
+         * see if there is room in the item to insert this
+         * name
+         */
+        data_size = sizeof(*di) + name_len + sizeof(struct btrfs_item);
+        leaf = path->nodes[0];
+        slot = path->slots[0];
+        if (data_size + btrfs_item_size_nr(leaf, slot) +
+            sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root)) {
+                ret = -EOVERFLOW;
+        } else {
+                /* plenty of insertion room */
+                ret = 0;
+        }
+out:
+        btrfs_free_path(path);
+        return ret;
+}
+
 /*
  * lookup a directory item based on index.  'dir' is the objectid
  * we're searching in, and 'mod' tells us if you plan on deleting the
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 22e98e04c2ea..a8f652dc940b 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -45,6 +45,11 @@
 #include "inode-map.h"
 #include "check-integrity.h"
 #include "rcu-string.h"
+#include "dev-replace.h"
+
+#ifdef CONFIG_X86
+#include <asm/cpufeature.h>
+#endif
 
 static struct extent_io_ops btree_extent_io_ops;
 static void end_workqueue_fn(struct btrfs_work *work);
@@ -217,26 +222,16 @@ static struct extent_map *btree_get_extent(struct inode *inode,
         write_lock(&em_tree->lock);
         ret = add_extent_mapping(em_tree, em);
         if (ret == -EEXIST) {
-                u64 failed_start = em->start;
-                u64 failed_len = em->len;
-
                 free_extent_map(em);
                 em = lookup_extent_mapping(em_tree, start, len);
-                if (em) {
-                        ret = 0;
-                } else {
-                        em = lookup_extent_mapping(em_tree, failed_start,
-                                                   failed_len);
-                        ret = -EIO;
-                }
+                if (!em)
+                        em = ERR_PTR(-EIO);
         } else if (ret) {
                 free_extent_map(em);
-                em = NULL;
+                em = ERR_PTR(ret);
         }
         write_unlock(&em_tree->lock);
 
-        if (ret)
-                em = ERR_PTR(ret);
 out:
         return em;
 }
@@ -393,7 +388,7 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
                 if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
                         break;
 
-                num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
+                num_copies = btrfs_num_copies(root->fs_info,
                                               eb->start, eb->len);
                 if (num_copies == 1)
                         break;
@@ -439,10 +434,6 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
                 WARN_ON(1);
                 return 0;
         }
-        if (eb->pages[0] != page) {
-                WARN_ON(1);
-                return 0;
-        }
         if (!PageUptodate(page)) {
                 WARN_ON(1);
                 return 0;
@@ -862,21 +853,37 @@ static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags,
                                  u64 bio_offset)
 {
+        int ret;
+
         /*
          * when we're called for a write, we're already in the async
          * submission context.  Just jump into btrfs_map_bio
          */
-        return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
+        ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
+        if (ret)
+                bio_endio(bio, ret);
+        return ret;
+}
+
+static int check_async_write(struct inode *inode, unsigned long bio_flags)
+{
+        if (bio_flags & EXTENT_BIO_TREE_LOG)
+                return 0;
+#ifdef CONFIG_X86
+        if (cpu_has_xmm4_2)
+                return 0;
+#endif
+        return 1;
 }
 
 static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags,
                                  u64 bio_offset)
 {
+        int async = check_async_write(inode, bio_flags);
         int ret;
 
         if (!(rw & REQ_WRITE)) {
-
                 /*
                  * called for a read, do the setup so that checksum validation
                  * can happen in the async kernel threads
@@ -884,20 +891,32 @@ static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                 ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
                                           bio, 1);
                 if (ret)
-                        return ret;
-                return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
-                                     mirror_num, 0);
+                        goto out_w_error;
+                ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
+                                    mirror_num, 0);
+        } else if (!async) {
+                ret = btree_csum_one_bio(bio);
+                if (ret)
+                        goto out_w_error;
+                ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
+                                    mirror_num, 0);
+        } else {
+                /*
+                 * kthread helpers are used to submit writes so that
+                 * checksumming can happen in parallel across all CPUs
+                 */
+                ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
+                                          inode, rw, bio, mirror_num, 0,
+                                          bio_offset,
+                                          __btree_submit_bio_start,
+                                          __btree_submit_bio_done);
         }
 
-        /*
-         * kthread helpers are used to submit writes so that checksumming
-         * can happen in parallel across all CPUs
-         */
-        return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
-                                   inode, rw, bio, mirror_num, 0,
-                                   bio_offset,
-                                   __btree_submit_bio_start,
-                                   __btree_submit_bio_done);
+        if (ret) {
+out_w_error:
+                bio_endio(bio, ret);
+        }
+        return ret;
 }
 
 #ifdef CONFIG_MIGRATION
@@ -982,6 +1001,7 @@ static void btree_invalidatepage(struct page *page, unsigned long offset)
 
 static int btree_set_page_dirty(struct page *page)
 {
+#ifdef DEBUG
         struct extent_buffer *eb;
 
         BUG_ON(!PagePrivate(page));
@@ -990,6 +1010,7 @@ static int btree_set_page_dirty(struct page *page)
         BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
         BUG_ON(!atomic_read(&eb->refs));
         btrfs_assert_tree_locked(eb);
+#endif
         return __set_page_dirty_nobuffers(page);
 }
 
@@ -1121,11 +1142,11 @@ void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                                           root->fs_info->dirty_metadata_bytes);
                         }
                         spin_unlock(&root->fs_info->delalloc_lock);
-                }
 
-                /* ugh, clear_extent_buffer_dirty needs to lock the page */
-                btrfs_set_lock_blocking(buf);
-                clear_extent_buffer_dirty(buf);
+                        /* ugh, clear_extent_buffer_dirty needs to lock the page */
+                        btrfs_set_lock_blocking(buf);
+                        clear_extent_buffer_dirty(buf);
+                }
         }
 }
 
@@ -1168,8 +1189,8 @@ static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
         atomic_set(&root->log_commit[0], 0);
         atomic_set(&root->log_commit[1], 0);
         atomic_set(&root->log_writers, 0);
+        atomic_set(&root->log_batch, 0);
         atomic_set(&root->orphan_inodes, 0);
-        root->log_batch = 0;
         root->log_transid = 0;
         root->last_log_commit = 0;
         extent_io_tree_init(&root->dirty_log_pages,
@@ -1185,7 +1206,7 @@ static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
         root->root_key.objectid = objectid;
         root->anon_dev = 0;
 
-        spin_lock_init(&root->root_times_lock);
+        spin_lock_init(&root->root_item_lock);
 }
 
 static int __must_check find_and_setup_root(struct btrfs_root *tree_root,
@@ -1667,9 +1688,10 @@ static int transaction_kthread(void *arg)
                 spin_unlock(&root->fs_info->trans_lock);
 
                 /* If the file system is aborted, this will always fail. */
-                trans = btrfs_join_transaction(root);
+                trans = btrfs_attach_transaction(root);
                 if (IS_ERR(trans)) {
-                        cannot_commit = true;
+                        if (PTR_ERR(trans) != -ENOENT)
+                                cannot_commit = true;
                         goto sleep;
                 }
                 if (transid == trans->transid) {
@@ -1994,13 +2016,11 @@ int open_ctree(struct super_block *sb,
         INIT_LIST_HEAD(&fs_info->trans_list);
         INIT_LIST_HEAD(&fs_info->dead_roots);
         INIT_LIST_HEAD(&fs_info->delayed_iputs);
-        INIT_LIST_HEAD(&fs_info->hashers);
         INIT_LIST_HEAD(&fs_info->delalloc_inodes);
         INIT_LIST_HEAD(&fs_info->ordered_operations);
         INIT_LIST_HEAD(&fs_info->caching_block_groups);
         spin_lock_init(&fs_info->delalloc_lock);
         spin_lock_init(&fs_info->trans_lock);
-        spin_lock_init(&fs_info->ref_cache_lock);
         spin_lock_init(&fs_info->fs_roots_radix_lock);
         spin_lock_init(&fs_info->delayed_iput_lock);
         spin_lock_init(&fs_info->defrag_inodes_lock);
@@ -2014,12 +2034,15 @@ int open_ctree(struct super_block *sb,
         INIT_LIST_HEAD(&fs_info->space_info);
         INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
         btrfs_mapping_init(&fs_info->mapping_tree);
-        btrfs_init_block_rsv(&fs_info->global_block_rsv);
-        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
-        btrfs_init_block_rsv(&fs_info->trans_block_rsv);
-        btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
-        btrfs_init_block_rsv(&fs_info->empty_block_rsv);
-        btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
+        btrfs_init_block_rsv(&fs_info->global_block_rsv,
+                             BTRFS_BLOCK_RSV_GLOBAL);
+        btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
+                             BTRFS_BLOCK_RSV_DELALLOC);
+        btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
+        btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
+        btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
+        btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
+                             BTRFS_BLOCK_RSV_DELOPS);
         atomic_set(&fs_info->nr_async_submits, 0);
         atomic_set(&fs_info->async_delalloc_pages, 0);
         atomic_set(&fs_info->async_submit_draining, 0);
@@ -2121,6 +2144,11 @@ int open_ctree(struct super_block *sb,
         init_rwsem(&fs_info->extent_commit_sem);
         init_rwsem(&fs_info->cleanup_work_sem);
         init_rwsem(&fs_info->subvol_sem);
+        fs_info->dev_replace.lock_owner = 0;
+        atomic_set(&fs_info->dev_replace.nesting_level, 0);
+        mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
+        mutex_init(&fs_info->dev_replace.lock_management_lock);
+        mutex_init(&fs_info->dev_replace.lock);
 
         spin_lock_init(&fs_info->qgroup_lock);
         fs_info->qgroup_tree = RB_ROOT;
@@ -2269,6 +2297,10 @@ int open_ctree(struct super_block *sb,
                            fs_info->thread_pool_size,
                            &fs_info->generic_worker);
 
+        btrfs_init_workers(&fs_info->flush_workers, "flush_delalloc",
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
+
         btrfs_init_workers(&fs_info->submit_workers, "submit",
                            min_t(u64, fs_devices->num_devices,
                            fs_info->thread_pool_size),
@@ -2340,6 +2372,7 @@ int open_ctree(struct super_block *sb,
         ret |= btrfs_start_workers(&fs_info->delayed_workers);
         ret |= btrfs_start_workers(&fs_info->caching_workers);
         ret |= btrfs_start_workers(&fs_info->readahead_workers);
+        ret |= btrfs_start_workers(&fs_info->flush_workers);
         if (ret) {
                 err = -ENOMEM;
                 goto fail_sb_buffer;
@@ -2408,7 +2441,11 @@ int open_ctree(struct super_block *sb,
                 goto fail_tree_roots;
         }
 
-        btrfs_close_extra_devices(fs_devices);
+        /*
+         * keep the device that is marked to be the target device for the
+         * dev_replace procedure
+         */
+        btrfs_close_extra_devices(fs_info, fs_devices, 0);
 
         if (!fs_devices->latest_bdev) {
                 printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
@@ -2480,6 +2517,14 @@ retry_root_backup:
                 goto fail_block_groups;
         }
 
+        ret = btrfs_init_dev_replace(fs_info);
+        if (ret) {
+                pr_err("btrfs: failed to init dev_replace: %d\n", ret);
+                goto fail_block_groups;
+        }
+
+        btrfs_close_extra_devices(fs_info, fs_devices, 1);
+
         ret = btrfs_init_space_info(fs_info);
         if (ret) {
                 printk(KERN_ERR "Failed to initial space info: %d\n", ret);
@@ -2491,6 +2536,15 @@ retry_root_backup:
                 printk(KERN_ERR "Failed to read block groups: %d\n", ret);
                 goto fail_block_groups;
         }
+        fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
+        if (fs_info->fs_devices->missing_devices >
+             fs_info->num_tolerated_disk_barrier_failures &&
+            !(sb->s_flags & MS_RDONLY)) {
+                printk(KERN_WARNING
+                       "Btrfs: too many missing devices, writeable mount is not allowed\n");
+                goto fail_block_groups;
+        }
 
         fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
                                                "btrfs-cleaner");
@@ -2619,6 +2673,13 @@ retry_root_backup:
                 return ret;
         }
 
+        ret = btrfs_resume_dev_replace_async(fs_info);
+        if (ret) {
+                pr_warn("btrfs: failed to resume dev_replace\n");
+                close_ctree(tree_root);
+                return ret;
+        }
+
         return 0;
 
 fail_qgroup:
@@ -2655,6 +2716,7 @@ fail_sb_buffer:
         btrfs_stop_workers(&fs_info->submit_workers);
         btrfs_stop_workers(&fs_info->delayed_workers);
         btrfs_stop_workers(&fs_info->caching_workers);
+        btrfs_stop_workers(&fs_info->flush_workers);
 fail_alloc:
 fail_iput:
         btrfs_mapping_tree_free(&fs_info->mapping_tree);
@@ -2874,12 +2936,10 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
                         printk_in_rcu("btrfs: disabling barriers on dev %s\n",
                                       rcu_str_deref(device->name));
                         device->nobarriers = 1;
-                }
-                if (!bio_flagged(bio, BIO_UPTODATE)) {
+                } else if (!bio_flagged(bio, BIO_UPTODATE)) {
                         ret = -EIO;
-                        if (!bio_flagged(bio, BIO_EOPNOTSUPP))
-                                btrfs_dev_stat_inc_and_print(device,
-                                        BTRFS_DEV_STAT_FLUSH_ERRS);
+                        btrfs_dev_stat_inc_and_print(device,
+                                BTRFS_DEV_STAT_FLUSH_ERRS);
                 }
 
                 /* drop the reference from the wait == 0 run */
@@ -2918,14 +2978,15 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 {
         struct list_head *head;
         struct btrfs_device *dev;
-        int errors = 0;
+        int errors_send = 0;
+        int errors_wait = 0;
         int ret;
 
         /* send down all the barriers */
         head = &info->fs_devices->devices;
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
-                        errors++;
+                        errors_send++;
                         continue;
                 }
                 if (!dev->in_fs_metadata || !dev->writeable)
@@ -2933,13 +2994,13 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 
                 ret = write_dev_flush(dev, 0);
                 if (ret)
-                        errors++;
+                        errors_send++;
         }
 
         /* wait for all the barriers */
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
-                        errors++;
+                        errors_wait++;
                         continue;
                 }
                 if (!dev->in_fs_metadata || !dev->writeable)
@@ -2947,13 +3008,87 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
 
                 ret = write_dev_flush(dev, 1);
                 if (ret)
-                        errors++;
+                        errors_wait++;
         }
-        if (errors)
+        if (errors_send > info->num_tolerated_disk_barrier_failures ||
+            errors_wait > info->num_tolerated_disk_barrier_failures)
                 return -EIO;
         return 0;
 }
 
+int btrfs_calc_num_tolerated_disk_barrier_failures(
+        struct btrfs_fs_info *fs_info)
+{
+        struct btrfs_ioctl_space_info space;
+        struct btrfs_space_info *sinfo;
+        u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
+                       BTRFS_BLOCK_GROUP_SYSTEM,
+                       BTRFS_BLOCK_GROUP_METADATA,
+                       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
+        int num_types = 4;
+        int i;
+        int c;
+        int num_tolerated_disk_barrier_failures =
+                (int)fs_info->fs_devices->num_devices;
+
+        for (i = 0; i < num_types; i++) {
+                struct btrfs_space_info *tmp;
+
+                sinfo = NULL;
+                rcu_read_lock();
+                list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
+                        if (tmp->flags == types[i]) {
+                                sinfo = tmp;
+                                break;
+                        }
+                }
+                rcu_read_unlock();
+
+                if (!sinfo)
+                        continue;
+
+                down_read(&sinfo->groups_sem);
+                for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
+                        if (!list_empty(&sinfo->block_groups[c])) {
+                                u64 flags;
+
+                                btrfs_get_block_group_info(
+                                        &sinfo->block_groups[c], &space);
+                                if (space.total_bytes == 0 ||
+                                    space.used_bytes == 0)
+                                        continue;
+                                flags = space.flags;
+                                /*
+                                 * return
+                                 * 0: if dup, single or RAID0 is configured for
+                                 *    any of metadata, system or data, else
+                                 * 1: if RAID5 is configured, or if RAID1 or
+                                 *    RAID10 is configured and only two mirrors
+                                 *    are used, else
+                                 * 2: if RAID6 is configured, else
+                                 * num_mirrors - 1: if RAID1 or RAID10 is
+                                 *                  configured and more than
+                                 *                  2 mirrors are used.
+                                 */
+                                if (num_tolerated_disk_barrier_failures > 0 &&
+                                    ((flags & (BTRFS_BLOCK_GROUP_DUP |
+                                               BTRFS_BLOCK_GROUP_RAID0)) ||
+                                     ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
+                                      == 0)))
+                                        num_tolerated_disk_barrier_failures = 0;
+                                else if (num_tolerated_disk_barrier_failures > 1
+                                         &&
+                                         (flags & (BTRFS_BLOCK_GROUP_RAID1 |
+                                                   BTRFS_BLOCK_GROUP_RAID10)))
+                                        num_tolerated_disk_barrier_failures = 1;
+                        }
+                }
+                up_read(&sinfo->groups_sem);
+        }
+
+        return num_tolerated_disk_barrier_failures;
+}
+
 int write_all_supers(struct btrfs_root *root, int max_mirrors)
 {
         struct list_head *head;
@@ -2976,8 +3111,16 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors)
         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
         head = &root->fs_info->fs_devices->devices;
 
-        if (do_barriers)
-                barrier_all_devices(root->fs_info);
+        if (do_barriers) {
+                ret = barrier_all_devices(root->fs_info);
+                if (ret) {
+                        mutex_unlock(
+                                &root->fs_info->fs_devices->device_list_mutex);
+                        btrfs_error(root->fs_info, ret,
+                                    "errors while submitting device barriers.");
+                        return ret;
+                }
+        }
 
         list_for_each_entry_rcu(dev, head, dev_list) {
                 if (!dev->bdev) {
@@ -3177,16 +3320,18 @@ int close_ctree(struct btrfs_root *root)
         smp_mb();
 
         /* pause restriper - we want to resume on mount */
-        btrfs_pause_balance(root->fs_info);
+        btrfs_pause_balance(fs_info);
 
-        btrfs_scrub_cancel(root);
+        btrfs_dev_replace_suspend_for_unmount(fs_info);
+
+        btrfs_scrub_cancel(fs_info);
 
         /* wait for any defraggers to finish */
         wait_event(fs_info->transaction_wait,
                    (atomic_read(&fs_info->defrag_running) == 0));
 
         /* clear out the rbtree of defraggable inodes */
-        btrfs_run_defrag_inodes(fs_info);
+        btrfs_cleanup_defrag_inodes(fs_info);
 
         if (!(fs_info->sb->s_flags & MS_RDONLY)) {
                 ret = btrfs_commit_super(root);
@@ -3211,10 +3356,6 @@ int close_ctree(struct btrfs_root *root)
                 printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
                        (unsigned long long)fs_info->delalloc_bytes);
         }
-        if (fs_info->total_ref_cache_size) {
-                printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
-                       (unsigned long long)fs_info->total_ref_cache_size);
-        }
 
         free_extent_buffer(fs_info->extent_root->node);
         free_extent_buffer(fs_info->extent_root->commit_root);
@@ -3250,6 +3391,7 @@ int close_ctree(struct btrfs_root *root)
         btrfs_stop_workers(&fs_info->delayed_workers);
         btrfs_stop_workers(&fs_info->caching_workers);
         btrfs_stop_workers(&fs_info->readahead_workers);
+        btrfs_stop_workers(&fs_info->flush_workers);
 
 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
         if (btrfs_test_opt(root, CHECK_INTEGRITY))
@@ -3294,14 +3436,12 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
         int was_dirty;
 
         btrfs_assert_tree_locked(buf);
-        if (transid != root->fs_info->generation) {
-                printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
+        if (transid != root->fs_info->generation)
+                WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
                        "found %llu running %llu\n",
                         (unsigned long long)buf->start,
                         (unsigned long long)transid,
                         (unsigned long long)root->fs_info->generation);
-                WARN_ON(1);
-        }
         was_dirty = set_extent_buffer_dirty(buf);
         if (!was_dirty) {
                 spin_lock(&root->fs_info->delalloc_lock);
@@ -3310,7 +3450,8 @@ void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
         }
 }
 
-void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
+static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
+                                        int flush_delayed)
 {
         /*
          * looks as though older kernels can get into trouble with
@@ -3322,36 +3463,26 @@ void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
         if (current->flags & PF_MEMALLOC)
                 return;
 
-        btrfs_balance_delayed_items(root);
+        if (flush_delayed)
+                btrfs_balance_delayed_items(root);
 
         num_dirty = root->fs_info->dirty_metadata_bytes;
 
         if (num_dirty > thresh) {
-                balance_dirty_pages_ratelimited_nr(
-                                   root->fs_info->btree_inode->i_mapping, 1);
+                balance_dirty_pages_ratelimited(
+                                   root->fs_info->btree_inode->i_mapping);
         }
         return;
 }
 
-void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
+void btrfs_btree_balance_dirty(struct btrfs_root *root)
 {
-        /*
-         * looks as though older kernels can get into trouble with
-         * this code, they end up stuck in balance_dirty_pages forever
-         */
-        u64 num_dirty;
-        unsigned long thresh = 32 * 1024 * 1024;
-
-        if (current->flags & PF_MEMALLOC)
-                return;
-
-        num_dirty = root->fs_info->dirty_metadata_bytes;
+        __btrfs_btree_balance_dirty(root, 1);
+}
 
-        if (num_dirty > thresh) {
-                balance_dirty_pages_ratelimited_nr(
-                                   root->fs_info->btree_inode->i_mapping, 1);
-        }
-        return;
+void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
+{
+        __btrfs_btree_balance_dirty(root, 0);
 }
 
 int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
@@ -3360,52 +3491,6 @@ int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
         return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
 }
 
-int btree_lock_page_hook(struct page *page, void *data,
-                                void (*flush_fn)(void *))
-{
-        struct inode *inode = page->mapping->host;
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct extent_buffer *eb;
-
-        /*
-         * We culled this eb but the page is still hanging out on the mapping,
-         * carry on.
-         */
-        if (!PagePrivate(page))
-                goto out;
-
-        eb = (struct extent_buffer *)page->private;
-        if (!eb) {
-                WARN_ON(1);
-                goto out;
-        }
-        if (page != eb->pages[0])
-                goto out;
-
-        if (!btrfs_try_tree_write_lock(eb)) {
-                flush_fn(data);
-                btrfs_tree_lock(eb);
-        }
-        btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
-
-        if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
-                spin_lock(&root->fs_info->delalloc_lock);
-                if (root->fs_info->dirty_metadata_bytes >= eb->len)
-                        root->fs_info->dirty_metadata_bytes -= eb->len;
-                else
-                        WARN_ON(1);
-                spin_unlock(&root->fs_info->delalloc_lock);
-        }
-
-        btrfs_tree_unlock(eb);
-out:
-        if (!trylock_page(page)) {
-                flush_fn(data);
-                lock_page(page);
-        }
-        return 0;
-}
-
 static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
                               int read_only)
 {
@@ -3608,7 +3693,7 @@ static int btrfs_destroy_marked_extents(struct btrfs_root *root,
 
         while (1) {
                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
-                                            mark);
+                                            mark, NULL);
                 if (ret)
                         break;
 
@@ -3663,7 +3748,7 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
 again:
         while (1) {
                 ret = find_first_extent_bit(unpin, 0, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret)
                         break;
 
@@ -3800,7 +3885,6 @@ int btrfs_cleanup_transaction(struct btrfs_root *root)
 }
 
 static struct extent_io_ops btree_extent_io_ops = {
-        .write_cache_pages_lock_hook = btree_lock_page_hook,
         .readpage_end_io_hook = btree_readpage_end_io_hook,
         .readpage_io_failed_hook = btree_io_failed_hook,
         .submit_bio_hook = btree_submit_bio_hook,
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index c5b00a735fef..305c33efb0e3 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -62,8 +62,8 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
 struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
                                               struct btrfs_key *location);
 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info);
-void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr);
-void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr);
+void btrfs_btree_balance_dirty(struct btrfs_root *root);
+void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root);
 void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root);
 void btrfs_mark_buffer_dirty(struct extent_buffer *buf);
 int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
@@ -95,6 +95,8 @@ struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
                                      u64 objectid);
 int btree_lock_page_hook(struct page *page, void *data,
                                 void (*flush_fn)(void *));
+int btrfs_calc_num_tolerated_disk_barrier_failures(
+        struct btrfs_fs_info *fs_info);
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 void btrfs_init_lockdep(void);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index ba58024d40d3..521e9d4424f6 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -33,6 +33,7 @@
 #include "volumes.h"
 #include "locking.h"
 #include "free-space-cache.h"
+#include "math.h"
 
 #undef SCRAMBLE_DELAYED_REFS
 
@@ -94,8 +95,8 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
                                      u64 flags, struct btrfs_disk_key *key,
                                      int level, struct btrfs_key *ins);
 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *extent_root, u64 alloc_bytes,
-                          u64 flags, int force);
+                          struct btrfs_root *extent_root, u64 flags,
+                          int force);
 static int find_next_key(struct btrfs_path *path, int level,
                          struct btrfs_key *key);
 static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
@@ -312,7 +313,8 @@ static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
         while (start < end) {
                 ret = find_first_extent_bit(info->pinned_extents, start,
                                             &extent_start, &extent_end,
-                                            EXTENT_DIRTY | EXTENT_UPTODATE);
+                                            EXTENT_DIRTY | EXTENT_UPTODATE,
+                                            NULL);
                 if (ret)
                         break;
 
@@ -648,24 +650,6 @@ void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
         rcu_read_unlock();
 }
 
-static u64 div_factor(u64 num, int factor)
-{
-        if (factor == 10)
-                return num;
-        num *= factor;
-        do_div(num, 10);
-        return num;
-}
-
-static u64 div_factor_fine(u64 num, int factor)
-{
-        if (factor == 100)
-                return num;
-        num *= factor;
-        do_div(num, 100);
-        return num;
-}
-
 u64 btrfs_find_block_group(struct btrfs_root *root,
                            u64 search_start, u64 search_hint, int owner)
 {
@@ -1834,7 +1818,7 @@ static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
 
 
         /* Tell the block device(s) that the sectors can be discarded */
-        ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD,
+        ret = btrfs_map_block(root->fs_info, REQ_DISCARD,
                               bytenr, &num_bytes, &bbio, 0);
         /* Error condition is -ENOMEM */
         if (!ret) {
@@ -2313,6 +2297,9 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                                 kfree(extent_op);
 
                                 if (ret) {
+                                        list_del_init(&locked_ref->cluster);
+                                        mutex_unlock(&locked_ref->mutex);
+
                                         printk(KERN_DEBUG "btrfs: run_delayed_extent_op returned %d\n", ret);
                                         spin_lock(&delayed_refs->lock);
                                         return ret;
@@ -2355,16 +2342,16 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
                 count++;
 
                 if (ret) {
+                        if (locked_ref) {
+                                list_del_init(&locked_ref->cluster);
+                                mutex_unlock(&locked_ref->mutex);
+                        }
                         printk(KERN_DEBUG "btrfs: run_one_delayed_ref returned %d\n", ret);
                         spin_lock(&delayed_refs->lock);
                         return ret;
                 }
 
 next:
-                do_chunk_alloc(trans, fs_info->extent_root,
-                               2 * 1024 * 1024,
-                               btrfs_get_alloc_profile(root, 0),
-                               CHUNK_ALLOC_NO_FORCE);
                 cond_resched();
                 spin_lock(&delayed_refs->lock);
         }
@@ -2478,10 +2465,6 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
         if (root == root->fs_info->extent_root)
                 root = root->fs_info->tree_root;
 
-        do_chunk_alloc(trans, root->fs_info->extent_root,
-                       2 * 1024 * 1024, btrfs_get_alloc_profile(root, 0),
-                       CHUNK_ALLOC_NO_FORCE);
-
         btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
 
         delayed_refs = &trans->transaction->delayed_refs;
@@ -2551,6 +2534,12 @@ again:
         }
 
         if (run_all) {
+                if (!list_empty(&trans->new_bgs)) {
+                        spin_unlock(&delayed_refs->lock);
+                        btrfs_create_pending_block_groups(trans, root);
+                        spin_lock(&delayed_refs->lock);
+                }
+
                 node = rb_first(&delayed_refs->root);
                 if (!node)
                         goto out;
@@ -3406,7 +3395,6 @@ alloc:
                                 return PTR_ERR(trans);
 
                         ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                             bytes + 2 * 1024 * 1024,
                                              alloc_target,
                                              CHUNK_ALLOC_NO_FORCE);
                         btrfs_end_transaction(trans, root);
@@ -3488,8 +3476,7 @@ static void force_metadata_allocation(struct btrfs_fs_info *info)
 }
 
 static int should_alloc_chunk(struct btrfs_root *root,
-                              struct btrfs_space_info *sinfo, u64 alloc_bytes,
-                              int force)
+                              struct btrfs_space_info *sinfo, int force)
 {
         struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
         u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
@@ -3504,7 +3491,8 @@ static int should_alloc_chunk(struct btrfs_root *root,
          * and purposes it's used space.  Don't worry about locking the
          * global_rsv, it doesn't change except when the transaction commits.
          */
-        num_allocated += global_rsv->size;
+        if (sinfo->flags & BTRFS_BLOCK_GROUP_METADATA)
+                num_allocated += global_rsv->size;
 
         /*
          * in limited mode, we want to have some free space up to
@@ -3518,15 +3506,8 @@ static int should_alloc_chunk(struct btrfs_root *root,
                 if (num_bytes - num_allocated < thresh)
                         return 1;
         }
-        thresh = btrfs_super_total_bytes(root->fs_info->super_copy);
-
-        /* 256MB or 2% of the FS */
-        thresh = max_t(u64, 256 * 1024 * 1024, div_factor_fine(thresh, 2));
-        /* system chunks need a much small threshold */
-        if (sinfo->flags & BTRFS_BLOCK_GROUP_SYSTEM)
-                thresh = 32 * 1024 * 1024;
 
-        if (num_bytes > thresh && sinfo->bytes_used < div_factor(num_bytes, 8))
+        if (num_allocated + 2 * 1024 * 1024 < div_factor(num_bytes, 8))
                 return 0;
         return 1;
 }
@@ -3576,8 +3557,7 @@ static void check_system_chunk(struct btrfs_trans_handle *trans,
 }
 
 static int do_chunk_alloc(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *extent_root, u64 alloc_bytes,
-                          u64 flags, int force)
+                          struct btrfs_root *extent_root, u64 flags, int force)
 {
         struct btrfs_space_info *space_info;
         struct btrfs_fs_info *fs_info = extent_root->fs_info;
@@ -3601,7 +3581,7 @@ again:
                 return 0;
         }
 
-        if (!should_alloc_chunk(extent_root, space_info, alloc_bytes, force)) {
+        if (!should_alloc_chunk(extent_root, space_info, force)) {
                 spin_unlock(&space_info->lock);
                 return 0;
         } else if (space_info->chunk_alloc) {
@@ -3669,6 +3649,60 @@ out:
         return ret;
 }
 
+static int can_overcommit(struct btrfs_root *root,
+                          struct btrfs_space_info *space_info, u64 bytes,
+                          enum btrfs_reserve_flush_enum flush)
+{
+        u64 profile = btrfs_get_alloc_profile(root, 0);
+        u64 avail;
+        u64 used;
+
+        used = space_info->bytes_used + space_info->bytes_reserved +
+                space_info->bytes_pinned + space_info->bytes_readonly +
+                space_info->bytes_may_use;
+
+        spin_lock(&root->fs_info->free_chunk_lock);
+        avail = root->fs_info->free_chunk_space;
+        spin_unlock(&root->fs_info->free_chunk_lock);
+
+        /*
+         * If we have dup, raid1 or raid10 then only half of the free
+         * space is actually useable.
+         */
+        if (profile & (BTRFS_BLOCK_GROUP_DUP |
+                       BTRFS_BLOCK_GROUP_RAID1 |
+                       BTRFS_BLOCK_GROUP_RAID10))
+                avail >>= 1;
+
+        /*
+         * 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)
+                avail >>= 3;
+        else
+                avail >>= 1;
+
+        if (used + bytes < space_info->total_bytes + avail)
+                return 1;
+        return 0;
+}
+
+static int writeback_inodes_sb_nr_if_idle_safe(struct super_block *sb,
+                                               unsigned long nr_pages,
+                                               enum wb_reason reason)
+{
+        if (!writeback_in_progress(sb->s_bdi) &&
+            down_read_trylock(&sb->s_umount)) {
+                writeback_inodes_sb_nr(sb, nr_pages, reason);
+                up_read(&sb->s_umount);
+                return 1;
+        }
+
+        return 0;
+}
+
 /*
  * shrink metadata reservation for delalloc
  */
@@ -3683,6 +3717,7 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
         long time_left;
         unsigned long nr_pages = (2 * 1024 * 1024) >> PAGE_CACHE_SHIFT;
         int loops = 0;
+        enum btrfs_reserve_flush_enum flush;
 
         trans = (struct btrfs_trans_handle *)current->journal_info;
         block_rsv = &root->fs_info->delalloc_block_rsv;
@@ -3693,21 +3728,30 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
         if (delalloc_bytes == 0) {
                 if (trans)
                         return;
-                btrfs_wait_ordered_extents(root, 0, 0);
+                btrfs_wait_ordered_extents(root, 0);
                 return;
         }
 
         while (delalloc_bytes && loops < 3) {
                 max_reclaim = min(delalloc_bytes, to_reclaim);
                 nr_pages = max_reclaim >> PAGE_CACHE_SHIFT;
-                writeback_inodes_sb_nr_if_idle(root->fs_info->sb, nr_pages,
-                                               WB_REASON_FS_FREE_SPACE);
+                writeback_inodes_sb_nr_if_idle_safe(root->fs_info->sb,
+                                                    nr_pages,
+                                                    WB_REASON_FS_FREE_SPACE);
 
+                /*
+                 * We need to wait for the async pages to actually start before
+                 * we do anything.
+                 */
+                wait_event(root->fs_info->async_submit_wait,
+                           !atomic_read(&root->fs_info->async_delalloc_pages));
+
+                if (!trans)
+                        flush = BTRFS_RESERVE_FLUSH_ALL;
+                else
+                        flush = BTRFS_RESERVE_NO_FLUSH;
                 spin_lock(&space_info->lock);
-                if (space_info->bytes_used + space_info->bytes_reserved +
-                    space_info->bytes_pinned + space_info->bytes_readonly +
-                    space_info->bytes_may_use + orig <=
-                    space_info->total_bytes) {
+                if (can_overcommit(root, space_info, orig, flush)) {
                         spin_unlock(&space_info->lock);
                         break;
                 }
@@ -3715,7 +3759,7 @@ static void shrink_delalloc(struct btrfs_root *root, u64 to_reclaim, u64 orig,
 
                 loops++;
                 if (wait_ordered && !trans) {
-                        btrfs_wait_ordered_extents(root, 0, 0);
+                        btrfs_wait_ordered_extents(root, 0);
                 } else {
                         time_left = schedule_timeout_killable(1);
                         if (time_left)
@@ -3784,11 +3828,12 @@ commit:
 }
 
 enum flush_state {
-        FLUSH_DELALLOC          =       1,
-        FLUSH_DELALLOC_WAIT     =       2,
-        FLUSH_DELAYED_ITEMS_NR  =       3,
-        FLUSH_DELAYED_ITEMS     =       4,
-        COMMIT_TRANS            =       5,
+        FLUSH_DELAYED_ITEMS_NR  =       1,
+        FLUSH_DELAYED_ITEMS     =       2,
+        FLUSH_DELALLOC          =       3,
+        FLUSH_DELALLOC_WAIT     =       4,
+        ALLOC_CHUNK             =       5,
+        COMMIT_TRANS            =       6,
 };
 
 static int flush_space(struct btrfs_root *root,
@@ -3800,11 +3845,6 @@ static int flush_space(struct btrfs_root *root,
         int ret = 0;
 
         switch (state) {
-        case FLUSH_DELALLOC:
-        case FLUSH_DELALLOC_WAIT:
-                shrink_delalloc(root, num_bytes, orig_bytes,
-                                state == FLUSH_DELALLOC_WAIT);
-                break;
         case FLUSH_DELAYED_ITEMS_NR:
         case FLUSH_DELAYED_ITEMS:
                 if (state == FLUSH_DELAYED_ITEMS_NR) {
@@ -3825,6 +3865,24 @@ static int flush_space(struct btrfs_root *root,
                 ret = btrfs_run_delayed_items_nr(trans, root, nr);
                 btrfs_end_transaction(trans, root);
                 break;
+        case FLUSH_DELALLOC:
+        case FLUSH_DELALLOC_WAIT:
+                shrink_delalloc(root, num_bytes, orig_bytes,
+                                state == FLUSH_DELALLOC_WAIT);
+                break;
+        case ALLOC_CHUNK:
+                trans = btrfs_join_transaction(root);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        break;
+                }
+                ret = do_chunk_alloc(trans, root->fs_info->extent_root,
+                                     btrfs_get_alloc_profile(root, 0),
+                                     CHUNK_ALLOC_NO_FORCE);
+                btrfs_end_transaction(trans, root);
+                if (ret == -ENOSPC)
+                        ret = 0;
+                break;
         case COMMIT_TRANS:
                 ret = may_commit_transaction(root, space_info, orig_bytes, 0);
                 break;
@@ -3840,7 +3898,7 @@ static int flush_space(struct btrfs_root *root,
  * @root - the root we're allocating for
  * @block_rsv - the block_rsv we're allocating for
  * @orig_bytes - the number of bytes we want
- * @flush - wether or not we can flush to make our reservation
+ * @flush - whether or not we can flush to make our reservation
  *
  * This will reserve orgi_bytes number of bytes from the space info associated
  * with the block_rsv.  If there is not enough space it will make an attempt to
@@ -3851,24 +3909,25 @@ static int flush_space(struct btrfs_root *root,
  */
 static int reserve_metadata_bytes(struct btrfs_root *root,
                                   struct btrfs_block_rsv *block_rsv,
-                                  u64 orig_bytes, int flush)
+                                  u64 orig_bytes,
+                                  enum btrfs_reserve_flush_enum flush)
 {
         struct btrfs_space_info *space_info = block_rsv->space_info;
         u64 used;
         u64 num_bytes = orig_bytes;
-        int flush_state = FLUSH_DELALLOC;
+        int flush_state = FLUSH_DELAYED_ITEMS_NR;
         int ret = 0;
         bool flushing = false;
-        bool committed = false;
 
 again:
         ret = 0;
         spin_lock(&space_info->lock);
         /*
-         * We only want to wait if somebody other than us is flushing and we are
-         * actually alloed to flush.
+         * We only want to wait if somebody other than us is flushing and we
+         * are actually allowed to flush all things.
          */
-        while (flush && !flushing && space_info->flush) {
+        while (flush == BTRFS_RESERVE_FLUSH_ALL && !flushing &&
+               space_info->flush) {
                 spin_unlock(&space_info->lock);
                 /*
                  * If we have a trans handle we can't wait because the flusher
@@ -3922,80 +3981,52 @@ again:
                         (orig_bytes * 2);
         }
 
-        if (ret) {
-                u64 profile = btrfs_get_alloc_profile(root, 0);
-                u64 avail;
-
-                /*
-                 * If we have a lot of space that's pinned, don't bother doing
-                 * the overcommit dance yet and just commit the transaction.
-                 */
-                avail = (space_info->total_bytes - space_info->bytes_used) * 8;
-                do_div(avail, 10);
-                if (space_info->bytes_pinned >= avail && flush && !committed) {
-                        space_info->flush = 1;
-                        flushing = true;
-                        spin_unlock(&space_info->lock);
-                        ret = may_commit_transaction(root, space_info,
-                                                     orig_bytes, 1);
-                        if (ret)
-                                goto out;
-                        committed = true;
-                        goto again;
-                }
-
-                spin_lock(&root->fs_info->free_chunk_lock);
-                avail = root->fs_info->free_chunk_space;
-
-                /*
-                 * If we have dup, raid1 or raid10 then only half of the free
-                 * space is actually useable.
-                 */
-                if (profile & (BTRFS_BLOCK_GROUP_DUP |
-                               BTRFS_BLOCK_GROUP_RAID1 |
-                               BTRFS_BLOCK_GROUP_RAID10))
-                        avail >>= 1;
-
-                /*
-                 * If we aren't flushing don't let us overcommit too much, say
-                 * 1/8th of the space.  If we can flush, let it overcommit up to
-                 * 1/2 of the space.
-                 */
-                if (flush)
-                        avail >>= 3;
-                else
-                        avail >>= 1;
-                 spin_unlock(&root->fs_info->free_chunk_lock);
-
-                if (used + num_bytes < space_info->total_bytes + avail) {
-                        space_info->bytes_may_use += orig_bytes;
-                        trace_btrfs_space_reservation(root->fs_info,
-                                "space_info", space_info->flags, orig_bytes, 1);
-                        ret = 0;
-                }
+        if (ret && can_overcommit(root, space_info, orig_bytes, flush)) {
+                space_info->bytes_may_use += orig_bytes;
+                trace_btrfs_space_reservation(root->fs_info, "space_info",
+                                              space_info->flags, orig_bytes,
+                                              1);
+                ret = 0;
         }
 
         /*
          * Couldn't make our reservation, save our place so while we're trying
          * to reclaim space we can actually use it instead of somebody else
          * stealing it from us.
+         *
+         * We make the other tasks wait for the flush only when we can flush
+         * all things.
          */
-        if (ret && flush) {
+        if (ret && flush == BTRFS_RESERVE_FLUSH_ALL) {
                 flushing = true;
                 space_info->flush = 1;
         }
 
         spin_unlock(&space_info->lock);
 
-        if (!ret || !flush)
+        if (!ret || flush == BTRFS_RESERVE_NO_FLUSH)
                 goto out;
 
         ret = flush_space(root, space_info, num_bytes, orig_bytes,
                           flush_state);
         flush_state++;
+
+        /*
+         * If we are FLUSH_LIMIT, we can not flush delalloc, or the deadlock
+         * would happen. So skip delalloc flush.
+         */
+        if (flush == BTRFS_RESERVE_FLUSH_LIMIT &&
+            (flush_state == FLUSH_DELALLOC ||
+             flush_state == FLUSH_DELALLOC_WAIT))
+                flush_state = ALLOC_CHUNK;
+
         if (!ret)
                 goto again;
-        else if (flush_state <= COMMIT_TRANS)
+        else if (flush == BTRFS_RESERVE_FLUSH_LIMIT &&
+                 flush_state < COMMIT_TRANS)
+                goto again;
+        else if (flush == BTRFS_RESERVE_FLUSH_ALL &&
+                 flush_state <= COMMIT_TRANS)
                 goto again;
 
 out:
@@ -4114,13 +4145,15 @@ static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
         return 0;
 }
 
-void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
+void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv, unsigned short type)
 {
         memset(rsv, 0, sizeof(*rsv));
         spin_lock_init(&rsv->lock);
+        rsv->type = type;
 }
 
-struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
+struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root,
+                                              unsigned short type)
 {
         struct btrfs_block_rsv *block_rsv;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -4129,7 +4162,7 @@ struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
         if (!block_rsv)
                 return NULL;
 
-        btrfs_init_block_rsv(block_rsv);
+        btrfs_init_block_rsv(block_rsv, type);
         block_rsv->space_info = __find_space_info(fs_info,
                                                   BTRFS_BLOCK_GROUP_METADATA);
         return block_rsv;
@@ -4138,13 +4171,15 @@ struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
 void btrfs_free_block_rsv(struct btrfs_root *root,
                           struct btrfs_block_rsv *rsv)
 {
+        if (!rsv)
+                return;
         btrfs_block_rsv_release(root, rsv, (u64)-1);
         kfree(rsv);
 }
 
-static inline int __block_rsv_add(struct btrfs_root *root,
-                                  struct btrfs_block_rsv *block_rsv,
-                                  u64 num_bytes, int flush)
+int btrfs_block_rsv_add(struct btrfs_root *root,
+                        struct btrfs_block_rsv *block_rsv, u64 num_bytes,
+                        enum btrfs_reserve_flush_enum flush)
 {
         int ret;
 
@@ -4160,20 +4195,6 @@ static inline int __block_rsv_add(struct btrfs_root *root,
         return ret;
 }
 
-int btrfs_block_rsv_add(struct btrfs_root *root,
-                        struct btrfs_block_rsv *block_rsv,
-                        u64 num_bytes)
-{
-        return __block_rsv_add(root, block_rsv, num_bytes, 1);
-}
-
-int btrfs_block_rsv_add_noflush(struct btrfs_root *root,
-                                struct btrfs_block_rsv *block_rsv,
-                                u64 num_bytes)
-{
-        return __block_rsv_add(root, block_rsv, num_bytes, 0);
-}
-
 int btrfs_block_rsv_check(struct btrfs_root *root,
                           struct btrfs_block_rsv *block_rsv, int min_factor)
 {
@@ -4192,9 +4213,9 @@ int btrfs_block_rsv_check(struct btrfs_root *root,
         return ret;
 }
 
-static inline int __btrfs_block_rsv_refill(struct btrfs_root *root,
-                                           struct btrfs_block_rsv *block_rsv,
-                                           u64 min_reserved, int flush)
+int btrfs_block_rsv_refill(struct btrfs_root *root,
+                           struct btrfs_block_rsv *block_rsv, u64 min_reserved,
+                           enum btrfs_reserve_flush_enum flush)
 {
         u64 num_bytes = 0;
         int ret = -ENOSPC;
@@ -4222,20 +4243,6 @@ static inline int __btrfs_block_rsv_refill(struct btrfs_root *root,
         return ret;
 }
 
-int btrfs_block_rsv_refill(struct btrfs_root *root,
-                           struct btrfs_block_rsv *block_rsv,
-                           u64 min_reserved)
-{
-        return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 1);
-}
-
-int btrfs_block_rsv_refill_noflush(struct btrfs_root *root,
-                                   struct btrfs_block_rsv *block_rsv,
-                                   u64 min_reserved)
-{
-        return __btrfs_block_rsv_refill(root, block_rsv, min_reserved, 0);
-}
-
 int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
                             struct btrfs_block_rsv *dst_rsv,
                             u64 num_bytes)
@@ -4416,10 +4423,10 @@ int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
         struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
         struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
         /*
-         * two for root back/forward refs, two for directory entries
-         * and one for root of the snapshot.
+         * two for root back/forward refs, two for directory entries,
+         * one for root of the snapshot and one for parent inode.
          */
-        u64 num_bytes = btrfs_calc_trans_metadata_size(root, 5);
+        u64 num_bytes = btrfs_calc_trans_metadata_size(root, 6);
         dst_rsv->space_info = src_rsv->space_info;
         return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
 }
@@ -4526,17 +4533,27 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
         u64 csum_bytes;
         unsigned nr_extents = 0;
         int extra_reserve = 0;
-        int flush = 1;
+        enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;
         int ret;
+        bool delalloc_lock = true;
 
-        /* Need to be holding the i_mutex here if we aren't free space cache */
-        if (btrfs_is_free_space_inode(inode))
-                flush = 0;
+        /* If we are a free space inode we need to not flush since we will be in
+         * the middle of a transaction commit.  We also don't need the delalloc
+         * mutex since we won't race with anybody.  We need this mostly to make
+         * lockdep shut its filthy mouth.
+         */
+        if (btrfs_is_free_space_inode(inode)) {
+                flush = BTRFS_RESERVE_NO_FLUSH;
+                delalloc_lock = false;
+        }
 
-        if (flush && btrfs_transaction_in_commit(root->fs_info))
+        if (flush != BTRFS_RESERVE_NO_FLUSH &&
+            btrfs_transaction_in_commit(root->fs_info))
                 schedule_timeout(1);
 
-        mutex_lock(&BTRFS_I(inode)->delalloc_mutex);
+        if (delalloc_lock)
+                mutex_lock(&BTRFS_I(inode)->delalloc_mutex);
+
         num_bytes = ALIGN(num_bytes, root->sectorsize);
 
         spin_lock(&BTRFS_I(inode)->lock);
@@ -4566,7 +4583,11 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
                 ret = btrfs_qgroup_reserve(root, num_bytes +
                                            nr_extents * root->leafsize);
                 if (ret) {
-                        mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
+                        spin_lock(&BTRFS_I(inode)->lock);
+                        calc_csum_metadata_size(inode, num_bytes, 0);
+                        spin_unlock(&BTRFS_I(inode)->lock);
+                        if (delalloc_lock)
+                                mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
                         return ret;
                 }
         }
@@ -4601,7 +4622,12 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
                                                       btrfs_ino(inode),
                                                       to_free, 0);
                 }
-                mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
+                if (root->fs_info->quota_enabled) {
+                        btrfs_qgroup_free(root, num_bytes +
+                                                nr_extents * root->leafsize);
+                }
+                if (delalloc_lock)
+                        mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
                 return ret;
         }
 
@@ -4613,7 +4639,9 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
         }
         BTRFS_I(inode)->reserved_extents += nr_extents;
         spin_unlock(&BTRFS_I(inode)->lock);
-        mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
+
+        if (delalloc_lock)
+                mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);
 
         if (to_reserve)
                 trace_btrfs_space_reservation(root->fs_info,"delalloc",
@@ -4963,9 +4991,13 @@ static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
 {
         struct btrfs_fs_info *fs_info = root->fs_info;
         struct btrfs_block_group_cache *cache = NULL;
+        struct btrfs_space_info *space_info;
+        struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;
         u64 len;
+        bool readonly;
 
         while (start <= end) {
+                readonly = false;
                 if (!cache ||
                     start >= cache->key.objectid + cache->key.offset) {
                         if (cache)
@@ -4983,15 +5015,30 @@ static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
                 }
 
                 start += len;
+                space_info = cache->space_info;
 
-                spin_lock(&cache->space_info->lock);
+                spin_lock(&space_info->lock);
                 spin_lock(&cache->lock);
                 cache->pinned -= len;
-                cache->space_info->bytes_pinned -= len;
-                if (cache->ro)
-                        cache->space_info->bytes_readonly += len;
+                space_info->bytes_pinned -= len;
+                if (cache->ro) {
+                        space_info->bytes_readonly += len;
+                        readonly = true;
+                }
                 spin_unlock(&cache->lock);
-                spin_unlock(&cache->space_info->lock);
+                if (!readonly && global_rsv->space_info == space_info) {
+                        spin_lock(&global_rsv->lock);
+                        if (!global_rsv->full) {
+                                len = min(len, global_rsv->size -
+                                          global_rsv->reserved);
+                                global_rsv->reserved += len;
+                                space_info->bytes_may_use += len;
+                                if (global_rsv->reserved >= global_rsv->size)
+                                        global_rsv->full = 1;
+                        }
+                        spin_unlock(&global_rsv->lock);
+                }
+                spin_unlock(&space_info->lock);
         }
 
         if (cache)
@@ -5018,7 +5065,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
 
         while (1) {
                 ret = find_first_extent_bit(unpin, 0, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret)
                         break;
 
@@ -5096,8 +5143,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                         ret = remove_extent_backref(trans, extent_root, path,
                                                     NULL, refs_to_drop,
                                                     is_data);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                         btrfs_release_path(path);
                         path->leave_spinning = 1;
 
@@ -5115,8 +5164,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                         btrfs_print_leaf(extent_root,
                                                          path->nodes[0]);
                         }
-                        if (ret < 0)
-                                goto abort;
+                        if (ret < 0) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                         extent_slot = path->slots[0];
                 }
         } else if (ret == -ENOENT) {
@@ -5130,7 +5181,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                        (unsigned long long)owner_objectid,
                        (unsigned long long)owner_offset);
         } else {
-                goto abort;
+                btrfs_abort_transaction(trans, extent_root, ret);
+                goto out;
         }
 
         leaf = path->nodes[0];
@@ -5140,8 +5192,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                 BUG_ON(found_extent || extent_slot != path->slots[0]);
                 ret = convert_extent_item_v0(trans, extent_root, path,
                                              owner_objectid, 0);
-                if (ret < 0)
-                        goto abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
 
                 btrfs_release_path(path);
                 path->leave_spinning = 1;
@@ -5158,8 +5212,11 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                                (unsigned long long)bytenr);
                         btrfs_print_leaf(extent_root, path->nodes[0]);
                 }
-                if (ret < 0)
-                        goto abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
+
                 extent_slot = path->slots[0];
                 leaf = path->nodes[0];
                 item_size = btrfs_item_size_nr(leaf, extent_slot);
@@ -5196,8 +5253,10 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
                         ret = remove_extent_backref(trans, extent_root, path,
                                                     iref, refs_to_drop,
                                                     is_data);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                 }
         } else {
                 if (found_extent) {
@@ -5214,27 +5273,29 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
 
                 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
                                       num_to_del);
-                if (ret)
-                        goto abort;
+                if (ret) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
                 btrfs_release_path(path);
 
                 if (is_data) {
                         ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
-                        if (ret)
-                                goto abort;
+                        if (ret) {
+                                btrfs_abort_transaction(trans, extent_root, ret);
+                                goto out;
+                        }
                 }
 
                 ret = update_block_group(trans, root, bytenr, num_bytes, 0);
-                if (ret)
-                        goto abort;
+                if (ret) {
+                        btrfs_abort_transaction(trans, extent_root, ret);
+                        goto out;
+                }
         }
 out:
         btrfs_free_path(path);
         return ret;
-
-abort:
-        btrfs_abort_transaction(trans, extent_root, ret);
-        goto out;
 }
 
 /*
@@ -5446,7 +5507,7 @@ wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
         return 0;
 }
 
-static int __get_block_group_index(u64 flags)
+int __get_raid_index(u64 flags)
 {
         int index;
 
@@ -5466,7 +5527,7 @@ static int __get_block_group_index(u64 flags)
 
 static int get_block_group_index(struct btrfs_block_group_cache *cache)
 {
-        return __get_block_group_index(cache->flags);
+        return __get_raid_index(cache->flags);
 }
 
 enum btrfs_loop_type {
@@ -5497,8 +5558,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
         struct btrfs_block_group_cache *used_block_group;
         u64 search_start = 0;
         int empty_cluster = 2 * 1024 * 1024;
-        int allowed_chunk_alloc = 0;
-        int done_chunk_alloc = 0;
         struct btrfs_space_info *space_info;
         int loop = 0;
         int index = 0;
@@ -5530,9 +5589,6 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
         if (btrfs_mixed_space_info(space_info))
                 use_cluster = false;
 
-        if (orig_root->ref_cows || empty_size)
-                allowed_chunk_alloc = 1;
-
         if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
                 last_ptr = &root->fs_info->meta_alloc_cluster;
                 if (!btrfs_test_opt(root, SSD))
@@ -5806,10 +5862,6 @@ checks:
 
                 trace_btrfs_reserve_extent(orig_root, block_group,
                                            search_start, num_bytes);
-                if (offset < search_start)
-                        btrfs_add_free_space(used_block_group, offset,
-                                             search_start - offset);
-                BUG_ON(offset > search_start);
                 if (used_block_group != block_group)
                         btrfs_put_block_group(used_block_group);
                 btrfs_put_block_group(block_group);
@@ -5842,34 +5894,17 @@ loop:
                 index = 0;
                 loop++;
                 if (loop == LOOP_ALLOC_CHUNK) {
-                       if (allowed_chunk_alloc) {
-                                ret = do_chunk_alloc(trans, root, num_bytes +
-                                                     2 * 1024 * 1024, data,
-                                                     CHUNK_ALLOC_LIMITED);
-                                /*
-                                 * Do not bail out on ENOSPC since we
-                                 * can do more things.
-                                 */
-                                if (ret < 0 && ret != -ENOSPC) {
-                                        btrfs_abort_transaction(trans,
-                                                                root, ret);
-                                        goto out;
-                                }
-                                allowed_chunk_alloc = 0;
-                                if (ret == 1)
-                                        done_chunk_alloc = 1;
-                        } else if (!done_chunk_alloc &&
-                                   space_info->force_alloc ==
-                                   CHUNK_ALLOC_NO_FORCE) {
-                                space_info->force_alloc = CHUNK_ALLOC_LIMITED;
+                        ret = do_chunk_alloc(trans, root, data,
+                                             CHUNK_ALLOC_FORCE);
+                        /*
+                         * Do not bail out on ENOSPC since we
+                         * can do more things.
+                         */
+                        if (ret < 0 && ret != -ENOSPC) {
+                                btrfs_abort_transaction(trans,
+                                                        root, ret);
+                                goto out;
                         }
-
-                       /*
-                        * We didn't allocate a chunk, go ahead and drop the
-                        * empty size and loop again.
-                        */
-                       if (!done_chunk_alloc)
-                               loop = LOOP_NO_EMPTY_SIZE;
                 }
 
                 if (loop == LOOP_NO_EMPTY_SIZE) {
@@ -5944,20 +5979,6 @@ int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
 
         data = btrfs_get_alloc_profile(root, data);
 again:
-        /*
-         * the only place that sets empty_size is btrfs_realloc_node, which
-         * is not called recursively on allocations
-         */
-        if (empty_size || root->ref_cows) {
-                ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                     num_bytes + 2 * 1024 * 1024, data,
-                                     CHUNK_ALLOC_NO_FORCE);
-                if (ret < 0 && ret != -ENOSPC) {
-                        btrfs_abort_transaction(trans, root, ret);
-                        return ret;
-                }
-        }
-
         WARN_ON(num_bytes < root->sectorsize);
         ret = find_free_extent(trans, root, num_bytes, empty_size,
                                hint_byte, ins, data);
@@ -5967,12 +5988,6 @@ again:
                         num_bytes = num_bytes >> 1;
                         num_bytes = num_bytes & ~(root->sectorsize - 1);
                         num_bytes = max(num_bytes, min_alloc_size);
-                        ret = do_chunk_alloc(trans, root->fs_info->extent_root,
-                                       num_bytes, data, CHUNK_ALLOC_FORCE);
-                        if (ret < 0 && ret != -ENOSPC) {
-                                btrfs_abort_transaction(trans, root, ret);
-                                return ret;
-                        }
                         if (num_bytes == min_alloc_size)
                                 final_tried = true;
                         goto again;
@@ -6295,7 +6310,8 @@ use_block_rsv(struct btrfs_trans_handle *trans,
         block_rsv = get_block_rsv(trans, root);
 
         if (block_rsv->size == 0) {
-                ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
+                ret = reserve_metadata_bytes(root, block_rsv, blocksize,
+                                             BTRFS_RESERVE_NO_FLUSH);
                 /*
                  * If we couldn't reserve metadata bytes try and use some from
                  * the global reserve.
@@ -6314,15 +6330,15 @@ use_block_rsv(struct btrfs_trans_handle *trans,
         ret = block_rsv_use_bytes(block_rsv, blocksize);
         if (!ret)
                 return block_rsv;
-        if (ret) {
+        if (ret && !block_rsv->failfast) {
                 static DEFINE_RATELIMIT_STATE(_rs,
                                 DEFAULT_RATELIMIT_INTERVAL,
                                 /*DEFAULT_RATELIMIT_BURST*/ 2);
-                if (__ratelimit(&_rs)) {
-                        printk(KERN_DEBUG "btrfs: block rsv returned %d\n", ret);
-                        WARN_ON(1);
-                }
-                ret = reserve_metadata_bytes(root, block_rsv, blocksize, 0);
+                if (__ratelimit(&_rs))
+                        WARN(1, KERN_DEBUG "btrfs: block rsv returned %d\n",
+                             ret);
+                ret = reserve_metadata_bytes(root, block_rsv, blocksize,
+                                             BTRFS_RESERVE_NO_FLUSH);
                 if (!ret) {
                         return block_rsv;
                 } else if (ret && block_rsv != global_rsv) {
@@ -7279,7 +7295,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root,
 
         alloc_flags = update_block_group_flags(root, cache->flags);
         if (alloc_flags != cache->flags) {
-                ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+                ret = do_chunk_alloc(trans, root, alloc_flags,
                                      CHUNK_ALLOC_FORCE);
                 if (ret < 0)
                         goto out;
@@ -7289,7 +7305,7 @@ int btrfs_set_block_group_ro(struct btrfs_root *root,
         if (!ret)
                 goto out;
         alloc_flags = get_alloc_profile(root, cache->space_info->flags);
-        ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+        ret = do_chunk_alloc(trans, root, alloc_flags,
                              CHUNK_ALLOC_FORCE);
         if (ret < 0)
                 goto out;
@@ -7303,7 +7319,7 @@ int btrfs_force_chunk_alloc(struct btrfs_trans_handle *trans,
                             struct btrfs_root *root, u64 type)
 {
         u64 alloc_flags = get_alloc_profile(root, type);
-        return do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags,
+        return do_chunk_alloc(trans, root, alloc_flags,
                               CHUNK_ALLOC_FORCE);
 }
 
@@ -7453,7 +7469,7 @@ int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
          */
         target = get_restripe_target(root->fs_info, block_group->flags);
         if (target) {
-                index = __get_block_group_index(extended_to_chunk(target));
+                index = __get_raid_index(extended_to_chunk(target));
         } else {
                 /*
                  * this is just a balance, so if we were marked as full
@@ -7487,7 +7503,8 @@ int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
                  * check to make sure we can actually find a chunk with enough
                  * space to fit our block group in.
                  */
-                if (device->total_bytes > device->bytes_used + min_free) {
+                if (device->total_bytes > device->bytes_used + min_free &&
+                    !device->is_tgtdev_for_dev_replace) {
                         ret = find_free_dev_extent(device, min_free,
                                                    &dev_offset, NULL);
                         if (!ret)
@@ -7810,6 +7827,34 @@ error:
         return ret;
 }
 
+void btrfs_create_pending_block_groups(struct btrfs_trans_handle *trans,
+                                       struct btrfs_root *root)
+{
+        struct btrfs_block_group_cache *block_group, *tmp;
+        struct btrfs_root *extent_root = root->fs_info->extent_root;
+        struct btrfs_block_group_item item;
+        struct btrfs_key key;
+        int ret = 0;
+
+        list_for_each_entry_safe(block_group, tmp, &trans->new_bgs,
+                                 new_bg_list) {
+                list_del_init(&block_group->new_bg_list);
+
+                if (ret)
+                        continue;
+
+                spin_lock(&block_group->lock);
+                memcpy(&item, &block_group->item, sizeof(item));
+                memcpy(&key, &block_group->key, sizeof(key));
+                spin_unlock(&block_group->lock);
+
+                ret = btrfs_insert_item(trans, extent_root, &key, &item,
+                                        sizeof(item));
+                if (ret)
+                        btrfs_abort_transaction(trans, extent_root, ret);
+        }
+}
+
 int btrfs_make_block_group(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root, u64 bytes_used,
                            u64 type, u64 chunk_objectid, u64 chunk_offset,
@@ -7843,6 +7888,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
         spin_lock_init(&cache->lock);
         INIT_LIST_HEAD(&cache->list);
         INIT_LIST_HEAD(&cache->cluster_list);
+        INIT_LIST_HEAD(&cache->new_bg_list);
 
         btrfs_init_free_space_ctl(cache);
 
@@ -7874,12 +7920,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans,
         ret = btrfs_add_block_group_cache(root->fs_info, cache);
         BUG_ON(ret); /* Logic error */
 
-        ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
-                                sizeof(cache->item));
-        if (ret) {
-                btrfs_abort_transaction(trans, extent_root, ret);
-                return ret;
-        }
+        list_add_tail(&cache->new_bg_list, &trans->new_bgs);
 
         set_avail_alloc_bits(extent_root->fs_info, type);
 
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index b08ea4717e9d..1b319df29eee 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -45,6 +45,7 @@ struct extent_page_data {
         struct bio *bio;
         struct extent_io_tree *tree;
         get_extent_t *get_extent;
+        unsigned long bio_flags;
 
         /* tells writepage not to lock the state bits for this range
          * it still does the unlocking
@@ -64,13 +65,13 @@ tree_fs_info(struct extent_io_tree *tree)
 
 int __init extent_io_init(void)
 {
-        extent_state_cache = kmem_cache_create("extent_state",
+        extent_state_cache = kmem_cache_create("btrfs_extent_state",
                         sizeof(struct extent_state), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_state_cache)
                 return -ENOMEM;
 
-        extent_buffer_cache = kmem_cache_create("extent_buffers",
+        extent_buffer_cache = kmem_cache_create("btrfs_extent_buffer",
                         sizeof(struct extent_buffer), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_buffer_cache)
@@ -340,12 +341,10 @@ static int insert_state(struct extent_io_tree *tree,
 {
         struct rb_node *node;
 
-        if (end < start) {
-                printk(KERN_ERR "btrfs end < start %llu %llu\n",
+        if (end < start)
+                WARN(1, KERN_ERR "btrfs end < start %llu %llu\n",
                        (unsigned long long)end,
                        (unsigned long long)start);
-                WARN_ON(1);
-        }
         state->start = start;
         state->end = end;
 
@@ -942,6 +941,7 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
  * @end:        the end offset in bytes (inclusive)
  * @bits:       the bits to set in this range
  * @clear_bits: the bits to clear in this range
+ * @cached_state:       state that we're going to cache
  * @mask:       the allocation mask
  *
  * This will go through and set bits for the given range.  If any states exist
@@ -951,7 +951,8 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
  * boundary bits like LOCK.
  */
 int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
-                       int bits, int clear_bits, gfp_t mask)
+                       int bits, int clear_bits,
+                       struct extent_state **cached_state, gfp_t mask)
 {
         struct extent_state *state;
         struct extent_state *prealloc = NULL;
@@ -968,6 +969,15 @@ again:
         }
 
         spin_lock(&tree->lock);
+        if (cached_state && *cached_state) {
+                state = *cached_state;
+                if (state->start <= start && state->end > start &&
+                    state->tree) {
+                        node = &state->rb_node;
+                        goto hit_next;
+                }
+        }
+
         /*
          * this search will find all the extents that end after
          * our range starts.
@@ -998,6 +1008,7 @@ hit_next:
          */
         if (state->start == start && state->end <= end) {
                 set_state_bits(tree, state, &bits);
+                cache_state(state, cached_state);
                 state = clear_state_bit(tree, state, &clear_bits, 0);
                 if (last_end == (u64)-1)
                         goto out;
@@ -1038,6 +1049,7 @@ hit_next:
                         goto out;
                 if (state->end <= end) {
                         set_state_bits(tree, state, &bits);
+                        cache_state(state, cached_state);
                         state = clear_state_bit(tree, state, &clear_bits, 0);
                         if (last_end == (u64)-1)
                                 goto out;
@@ -1076,6 +1088,7 @@ hit_next:
                                    &bits);
                 if (err)
                         extent_io_tree_panic(tree, err);
+                cache_state(prealloc, cached_state);
                 prealloc = NULL;
                 start = this_end + 1;
                 goto search_again;
@@ -1098,6 +1111,7 @@ hit_next:
                         extent_io_tree_panic(tree, err);
 
                 set_state_bits(tree, prealloc, &bits);
+                cache_state(prealloc, cached_state);
                 clear_state_bit(tree, prealloc, &clear_bits, 0);
                 prealloc = NULL;
                 goto out;
@@ -1150,6 +1164,14 @@ int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
                               NULL, cached_state, mask);
 }
 
+int set_extent_defrag(struct extent_io_tree *tree, u64 start, u64 end,
+                      struct extent_state **cached_state, gfp_t mask)
+{
+        return set_extent_bit(tree, start, end,
+                              EXTENT_DELALLOC | EXTENT_UPTODATE | EXTENT_DEFRAG,
+                              NULL, cached_state, mask);
+}
+
 int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
                        gfp_t mask)
 {
@@ -1294,18 +1316,42 @@ out:
  * If nothing was found, 1 is returned. If found something, return 0.
  */
 int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
-                          u64 *start_ret, u64 *end_ret, int bits)
+                          u64 *start_ret, u64 *end_ret, int bits,
+                          struct extent_state **cached_state)
 {
         struct extent_state *state;
+        struct rb_node *n;
         int ret = 1;
 
         spin_lock(&tree->lock);
+        if (cached_state && *cached_state) {
+                state = *cached_state;
+                if (state->end == start - 1 && state->tree) {
+                        n = rb_next(&state->rb_node);
+                        while (n) {
+                                state = rb_entry(n, struct extent_state,
+                                                 rb_node);
+                                if (state->state & bits)
+                                        goto got_it;
+                                n = rb_next(n);
+                        }
+                        free_extent_state(*cached_state);
+                        *cached_state = NULL;
+                        goto out;
+                }
+                free_extent_state(*cached_state);
+                *cached_state = NULL;
+        }
+
         state = find_first_extent_bit_state(tree, start, bits);
+got_it:
         if (state) {
+                cache_state(state, cached_state);
                 *start_ret = state->start;
                 *end_ret = state->end;
                 ret = 0;
         }
+out:
         spin_unlock(&tree->lock);
         return ret;
 }
@@ -1871,12 +1917,12 @@ static void repair_io_failure_callback(struct bio *bio, int err)
  * the standard behavior is to write all copies in a raid setup. here we only
  * want to write the one bad copy. so we do the mapping for ourselves and issue
  * submit_bio directly.
- * to avoid any synchonization issues, wait for the data after writing, which
+ * to avoid any synchronization issues, wait for the data after writing, which
  * actually prevents the read that triggered the error from finishing.
  * currently, there can be no more than two copies of every data bit. thus,
  * exactly one rewrite is required.
  */
-int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
+int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
                         u64 length, u64 logical, struct page *page,
                         int mirror_num)
 {
@@ -1898,7 +1944,7 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
         bio->bi_size = 0;
         map_length = length;
 
-        ret = btrfs_map_block(map_tree, WRITE, logical,
+        ret = btrfs_map_block(fs_info, WRITE, logical,
                               &map_length, &bbio, mirror_num);
         if (ret) {
                 bio_put(bio);
@@ -1936,14 +1982,13 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
 int repair_eb_io_failure(struct btrfs_root *root, struct extent_buffer *eb,
                          int mirror_num)
 {
-        struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
         u64 start = eb->start;
         unsigned long i, num_pages = num_extent_pages(eb->start, eb->len);
         int ret = 0;
 
         for (i = 0; i < num_pages; i++) {
                 struct page *p = extent_buffer_page(eb, i);
-                ret = repair_io_failure(map_tree, start, PAGE_CACHE_SIZE,
+                ret = repair_io_failure(root->fs_info, start, PAGE_CACHE_SIZE,
                                         start, p, mirror_num);
                 if (ret)
                         break;
@@ -1962,7 +2007,7 @@ static int clean_io_failure(u64 start, struct page *page)
         u64 private;
         u64 private_failure;
         struct io_failure_record *failrec;
-        struct btrfs_mapping_tree *map_tree;
+        struct btrfs_fs_info *fs_info;
         struct extent_state *state;
         int num_copies;
         int did_repair = 0;
@@ -1998,11 +2043,11 @@ static int clean_io_failure(u64 start, struct page *page)
         spin_unlock(&BTRFS_I(inode)->io_tree.lock);
 
         if (state && state->start == failrec->start) {
-                map_tree = &BTRFS_I(inode)->root->fs_info->mapping_tree;
-                num_copies = btrfs_num_copies(map_tree, failrec->logical,
-                                                failrec->len);
+                fs_info = BTRFS_I(inode)->root->fs_info;
+                num_copies = btrfs_num_copies(fs_info, failrec->logical,
+                                              failrec->len);
                 if (num_copies > 1)  {
-                        ret = repair_io_failure(map_tree, start, failrec->len,
+                        ret = repair_io_failure(fs_info, start, failrec->len,
                                                 failrec->logical, page,
                                                 failrec->failed_mirror);
                         did_repair = !ret;
@@ -2068,7 +2113,7 @@ static int bio_readpage_error(struct bio *failed_bio, struct page *page,
                 }
                 read_unlock(&em_tree->lock);
 
-                if (!em || IS_ERR(em)) {
+                if (!em) {
                         kfree(failrec);
                         return -EIO;
                 }
@@ -2111,9 +2156,8 @@ static int bio_readpage_error(struct bio *failed_bio, struct page *page,
                  * clean_io_failure() clean all those errors at once.
                  */
         }
-        num_copies = btrfs_num_copies(
-                              &BTRFS_I(inode)->root->fs_info->mapping_tree,
-                              failrec->logical, failrec->len);
+        num_copies = btrfs_num_copies(BTRFS_I(inode)->root->fs_info,
+                                      failrec->logical, failrec->len);
         if (num_copies == 1) {
                 /*
                  * we only have a single copy of the data, so don't bother with
@@ -2304,8 +2348,8 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
                 struct extent_state *cached = NULL;
                 struct extent_state *state;
 
-                pr_debug("end_bio_extent_readpage: bi_vcnt=%d, idx=%d, err=%d, "
-                         "mirror=%ld\n", bio->bi_vcnt, bio->bi_idx, err,
+                pr_debug("end_bio_extent_readpage: bi_sector=%llu, err=%d, "
+                         "mirror=%ld\n", (u64)bio->bi_sector, err,
                          (long int)bio->bi_bdev);
                 tree = &BTRFS_I(page->mapping->host)->io_tree;
 
@@ -2418,10 +2462,6 @@ btrfs_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs,
         return bio;
 }
 
-/*
- * Since writes are async, they will only return -ENOMEM.
- * Reads can return the full range of I/O error conditions.
- */
 static int __must_check submit_one_bio(int rw, struct bio *bio,
                                        int mirror_num, unsigned long bio_flags)
 {
@@ -2709,12 +2749,15 @@ static int __extent_read_full_page(struct extent_io_tree *tree,
                                          end_bio_extent_readpage, mirror_num,
                                          *bio_flags,
                                          this_bio_flag);
-                        BUG_ON(ret == -ENOMEM);
-                        nr++;
-                        *bio_flags = this_bio_flag;
+                        if (!ret) {
+                                nr++;
+                                *bio_flags = this_bio_flag;
+                        }
                 }
-                if (ret)
+                if (ret) {
                         SetPageError(page);
+                        unlock_extent(tree, cur, cur + iosize - 1);
+                }
                 cur = cur + iosize;
                 pg_offset += iosize;
         }
@@ -3161,12 +3204,16 @@ static int write_one_eb(struct extent_buffer *eb,
         struct block_device *bdev = fs_info->fs_devices->latest_bdev;
         u64 offset = eb->start;
         unsigned long i, num_pages;
+        unsigned long bio_flags = 0;
         int rw = (epd->sync_io ? WRITE_SYNC : WRITE);
         int ret = 0;
 
         clear_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
         num_pages = num_extent_pages(eb->start, eb->len);
         atomic_set(&eb->io_pages, num_pages);
+        if (btrfs_header_owner(eb) == BTRFS_TREE_LOG_OBJECTID)
+                bio_flags = EXTENT_BIO_TREE_LOG;
+
         for (i = 0; i < num_pages; i++) {
                 struct page *p = extent_buffer_page(eb, i);
 
@@ -3175,7 +3222,8 @@ static int write_one_eb(struct extent_buffer *eb,
                 ret = submit_extent_page(rw, eb->tree, p, offset >> 9,
                                          PAGE_CACHE_SIZE, 0, bdev, &epd->bio,
                                          -1, end_bio_extent_buffer_writepage,
-                                         0, 0, 0);
+                                         0, epd->bio_flags, bio_flags);
+                epd->bio_flags = bio_flags;
                 if (ret) {
                         set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
                         SetPageError(p);
@@ -3210,6 +3258,7 @@ int btree_write_cache_pages(struct address_space *mapping,
                 .tree = tree,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
         int ret = 0;
         int done = 0;
@@ -3254,19 +3303,34 @@ retry:
                                 break;
                         }
 
+                        spin_lock(&mapping->private_lock);
+                        if (!PagePrivate(page)) {
+                                spin_unlock(&mapping->private_lock);
+                                continue;
+                        }
+
                         eb = (struct extent_buffer *)page->private;
+
+                        /*
+                         * Shouldn't happen and normally this would be a BUG_ON
+                         * but no sense in crashing the users box for something
+                         * we can survive anyway.
+                         */
                         if (!eb) {
+                                spin_unlock(&mapping->private_lock);
                                 WARN_ON(1);
                                 continue;
                         }
 
-                        if (eb == prev_eb)
+                        if (eb == prev_eb) {
+                                spin_unlock(&mapping->private_lock);
                                 continue;
+                        }
 
-                        if (!atomic_inc_not_zero(&eb->refs)) {
-                                WARN_ON(1);
+                        ret = atomic_inc_not_zero(&eb->refs);
+                        spin_unlock(&mapping->private_lock);
+                        if (!ret)
                                 continue;
-                        }
 
                         prev_eb = eb;
                         ret = lock_extent_buffer_for_io(eb, fs_info, &epd);
@@ -3457,7 +3521,7 @@ static void flush_epd_write_bio(struct extent_page_data *epd)
                 if (epd->sync_io)
                         rw = WRITE_SYNC;
 
-                ret = submit_one_bio(rw, epd->bio, 0, 0);
+                ret = submit_one_bio(rw, epd->bio, 0, epd->bio_flags);
                 BUG_ON(ret < 0); /* -ENOMEM */
                 epd->bio = NULL;
         }
@@ -3480,6 +3544,7 @@ int extent_write_full_page(struct extent_io_tree *tree, struct page *page,
                 .get_extent = get_extent,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
 
         ret = __extent_writepage(page, wbc, &epd);
@@ -3504,6 +3569,7 @@ int extent_write_locked_range(struct extent_io_tree *tree, struct inode *inode,
                 .get_extent = get_extent,
                 .extent_locked = 1,
                 .sync_io = mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
         struct writeback_control wbc_writepages = {
                 .sync_mode      = mode,
@@ -3543,6 +3609,7 @@ int extent_writepages(struct extent_io_tree *tree,
                 .get_extent = get_extent,
                 .extent_locked = 0,
                 .sync_io = wbc->sync_mode == WB_SYNC_ALL,
+                .bio_flags = 0,
         };
 
         ret = extent_write_cache_pages(tree, mapping, wbc,
@@ -3920,18 +3987,6 @@ out:
         return ret;
 }
 
-inline struct page *extent_buffer_page(struct extent_buffer *eb,
-                                              unsigned long i)
-{
-        return eb->pages[i];
-}
-
-inline unsigned long num_extent_pages(u64 start, u64 len)
-{
-        return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
-                (start >> PAGE_CACHE_SHIFT);
-}
-
 static void __free_extent_buffer(struct extent_buffer *eb)
 {
 #if LEAK_DEBUG
@@ -4047,8 +4102,8 @@ struct extent_buffer *alloc_dummy_extent_buffer(u64 start, unsigned long len)
 
         return eb;
 err:
-        for (i--; i > 0; i--)
-                __free_page(eb->pages[i]);
+        for (; i > 0; i--)
+                __free_page(eb->pages[i - 1]);
         __free_extent_buffer(eb);
         return NULL;
 }
@@ -4192,10 +4247,8 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
 
         for (i = 0; i < num_pages; i++, index++) {
                 p = find_or_create_page(mapping, index, GFP_NOFS);
-                if (!p) {
-                        WARN_ON(1);
+                if (!p)
                         goto free_eb;
-                }
 
                 spin_lock(&mapping->private_lock);
                 if (PagePrivate(p)) {
@@ -4338,7 +4391,6 @@ static int release_extent_buffer(struct extent_buffer *eb, gfp_t mask)
 
                 /* Should be safe to release our pages at this point */
                 btrfs_release_extent_buffer_page(eb, 0);
-
                 call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);
                 return 1;
         }
@@ -4661,10 +4713,9 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
         }
 
         if (start + min_len > eb->len) {
-                printk(KERN_ERR "btrfs bad mapping eb start %llu len %lu, "
+                WARN(1, KERN_ERR "btrfs bad mapping eb start %llu len %lu, "
                        "wanted %lu %lu\n", (unsigned long long)eb->start,
                        eb->len, start, min_len);
-                WARN_ON(1);
                 return -EINVAL;
         }
 
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 25900af5b15d..2eacfabd3263 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -27,6 +27,7 @@
  * type for this bio
  */
 #define EXTENT_BIO_COMPRESSED 1
+#define EXTENT_BIO_TREE_LOG 2
 #define EXTENT_BIO_FLAG_SHIFT 16
 
 /* these are bit numbers for test/set bit */
@@ -232,11 +233,15 @@ int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
 int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
                        gfp_t mask);
 int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
-                       int bits, int clear_bits, gfp_t mask);
+                       int bits, int clear_bits,
+                       struct extent_state **cached_state, gfp_t mask);
 int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end,
                         struct extent_state **cached_state, gfp_t mask);
+int set_extent_defrag(struct extent_io_tree *tree, u64 start, u64 end,
+                      struct extent_state **cached_state, gfp_t mask);
 int find_first_extent_bit(struct extent_io_tree *tree, u64 start,
-                          u64 *start_ret, u64 *end_ret, int bits);
+                          u64 *start_ret, u64 *end_ret, int bits,
+                          struct extent_state **cached_state);
 struct extent_state *find_first_extent_bit_state(struct extent_io_tree *tree,
                                                  u64 start, int bits);
 int extent_invalidatepage(struct extent_io_tree *tree,
@@ -277,8 +282,18 @@ void free_extent_buffer_stale(struct extent_buffer *eb);
 int read_extent_buffer_pages(struct extent_io_tree *tree,
                              struct extent_buffer *eb, u64 start, int wait,
                              get_extent_t *get_extent, int mirror_num);
-unsigned long num_extent_pages(u64 start, u64 len);
-struct page *extent_buffer_page(struct extent_buffer *eb, unsigned long i);
+
+static inline unsigned long num_extent_pages(u64 start, u64 len)
+{
+        return ((start + len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT) -
+                (start >> PAGE_CACHE_SHIFT);
+}
+
+static inline struct page *extent_buffer_page(struct extent_buffer *eb,
+                                              unsigned long i)
+{
+        return eb->pages[i];
+}
 
 static inline void extent_buffer_get(struct extent_buffer *eb)
 {
@@ -322,9 +337,9 @@ struct bio *
 btrfs_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs,
                 gfp_t gfp_flags);
 
-struct btrfs_mapping_tree;
+struct btrfs_fs_info;
 
-int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
+int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
                         u64 length, u64 logical, struct page *page,
                         int mirror_num);
 int end_extent_writepage(struct page *page, int err, u64 start, u64 end);
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 7c97b3301459..f169d6b11d7f 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -11,7 +11,7 @@ static struct kmem_cache *extent_map_cache;
 
 int __init extent_map_init(void)
 {
-        extent_map_cache = kmem_cache_create("extent_map",
+        extent_map_cache = kmem_cache_create("btrfs_extent_map",
                         sizeof(struct extent_map), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!extent_map_cache)
@@ -35,6 +35,7 @@ void extent_map_exit(void)
 void extent_map_tree_init(struct extent_map_tree *tree)
 {
         tree->map = RB_ROOT;
+        INIT_LIST_HEAD(&tree->modified_extents);
         rwlock_init(&tree->lock);
 }
 
@@ -48,13 +49,15 @@ void extent_map_tree_init(struct extent_map_tree *tree)
 struct extent_map *alloc_extent_map(void)
 {
         struct extent_map *em;
-        em = kmem_cache_alloc(extent_map_cache, GFP_NOFS);
+        em = kmem_cache_zalloc(extent_map_cache, GFP_NOFS);
         if (!em)
                 return NULL;
         em->in_tree = 0;
         em->flags = 0;
         em->compress_type = BTRFS_COMPRESS_NONE;
+        em->generation = 0;
         atomic_set(&em->refs, 1);
+        INIT_LIST_HEAD(&em->list);
         return em;
 }
 
@@ -72,6 +75,7 @@ void free_extent_map(struct extent_map *em)
         WARN_ON(atomic_read(&em->refs) == 0);
         if (atomic_dec_and_test(&em->refs)) {
                 WARN_ON(em->in_tree);
+                WARN_ON(!list_empty(&em->list));
                 kmem_cache_free(extent_map_cache, em);
         }
 }
@@ -194,10 +198,17 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                         merge = rb_entry(rb, struct extent_map, rb_node);
                 if (rb && mergable_maps(merge, em)) {
                         em->start = merge->start;
+                        em->orig_start = merge->orig_start;
                         em->len += merge->len;
                         em->block_len += merge->block_len;
                         em->block_start = merge->block_start;
                         merge->in_tree = 0;
+                        em->mod_len = (em->mod_len + em->mod_start) - merge->mod_start;
+                        em->mod_start = merge->mod_start;
+                        em->generation = max(em->generation, merge->generation);
+                        list_move(&em->list, &tree->modified_extents);
+
+                        list_del_init(&merge->list);
                         rb_erase(&merge->rb_node, &tree->map);
                         free_extent_map(merge);
                 }
@@ -211,14 +222,30 @@ static void try_merge_map(struct extent_map_tree *tree, struct extent_map *em)
                 em->block_len += merge->len;
                 rb_erase(&merge->rb_node, &tree->map);
                 merge->in_tree = 0;
+                em->mod_len = (merge->mod_start + merge->mod_len) - em->mod_start;
+                em->generation = max(em->generation, merge->generation);
+                list_del_init(&merge->list);
                 free_extent_map(merge);
         }
 }
 
-int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
+/**
+ * unpin_extent_cache - unpin an extent from the cache
+ * @tree:       tree to unpin the extent in
+ * @start:      logical offset in the file
+ * @len:        length of the extent
+ * @gen:        generation that this extent has been modified in
+ *
+ * Called after an extent has been written to disk properly.  Set the generation
+ * to the generation that actually added the file item to the inode so we know
+ * we need to sync this extent when we call fsync().
+ */
+int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len,
+                       u64 gen)
 {
         int ret = 0;
         struct extent_map *em;
+        bool prealloc = false;
 
         write_lock(&tree->lock);
         em = lookup_extent_mapping(tree, start, len);
@@ -228,10 +255,24 @@ int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len)
         if (!em)
                 goto out;
 
+        list_move(&em->list, &tree->modified_extents);
+        em->generation = gen;
         clear_bit(EXTENT_FLAG_PINNED, &em->flags);
+        em->mod_start = em->start;
+        em->mod_len = em->len;
+
+        if (test_bit(EXTENT_FLAG_FILLING, &em->flags)) {
+                prealloc = true;
+                clear_bit(EXTENT_FLAG_FILLING, &em->flags);
+        }
 
         try_merge_map(tree, em);
 
+        if (prealloc) {
+                em->mod_start = em->start;
+                em->mod_len = em->len;
+        }
+
         free_extent_map(em);
 out:
         write_unlock(&tree->lock);
@@ -269,6 +310,9 @@ int add_extent_mapping(struct extent_map_tree *tree,
         }
         atomic_inc(&em->refs);
 
+        em->mod_start = em->start;
+        em->mod_len = em->len;
+
         try_merge_map(tree, em);
 out:
         return ret;
@@ -358,6 +402,8 @@ int remove_extent_mapping(struct extent_map_tree *tree, struct extent_map *em)
 
         WARN_ON(test_bit(EXTENT_FLAG_PINNED, &em->flags));
         rb_erase(&em->rb_node, &tree->map);
+        if (!test_bit(EXTENT_FLAG_LOGGING, &em->flags))
+                list_del_init(&em->list);
         em->in_tree = 0;
         return ret;
 }
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index 1195f09761fe..922943ce29e8 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -13,6 +13,8 @@
 #define EXTENT_FLAG_COMPRESSED 1
 #define EXTENT_FLAG_VACANCY 2 /* no file extent item found */
 #define EXTENT_FLAG_PREALLOC 3 /* pre-allocated extent */
+#define EXTENT_FLAG_LOGGING 4 /* Logging this extent */
+#define EXTENT_FLAG_FILLING 5 /* Filling in a preallocated extent */
 
 struct extent_map {
         struct rb_node rb_node;
@@ -20,18 +22,24 @@ struct extent_map {
         /* all of these are in bytes */
         u64 start;
         u64 len;
+        u64 mod_start;
+        u64 mod_len;
         u64 orig_start;
+        u64 orig_block_len;
         u64 block_start;
         u64 block_len;
+        u64 generation;
         unsigned long flags;
         struct block_device *bdev;
         atomic_t refs;
         unsigned int in_tree;
         unsigned int compress_type;
+        struct list_head list;
 };
 
 struct extent_map_tree {
         struct rb_root map;
+        struct list_head modified_extents;
         rwlock_t lock;
 };
 
@@ -60,7 +68,7 @@ struct extent_map *alloc_extent_map(void);
 void free_extent_map(struct extent_map *em);
 int __init extent_map_init(void);
 void extent_map_exit(void);
-int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len);
+int unpin_extent_cache(struct extent_map_tree *tree, u64 start, u64 len, u64 gen);
 struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
                                          u64 start, u64 len);
 #endif
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 857d93cd01dc..bd38cef42358 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -25,11 +25,12 @@
 #include "transaction.h"
 #include "print-tree.h"
 
-#define __MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
+#define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
                                    sizeof(struct btrfs_item) * 2) / \
                                   size) - 1))
 
-#define MAX_CSUM_ITEMS(r, size) (min(__MAX_CSUM_ITEMS(r, size), PAGE_CACHE_SIZE))
+#define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
+                                       PAGE_CACHE_SIZE))
 
 #define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \
                                    sizeof(struct btrfs_ordered_sum)) / \
@@ -132,7 +133,6 @@ fail:
         return ERR_PTR(ret);
 }
 
-
 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
                              struct btrfs_path *path, u64 objectid,
@@ -150,6 +150,26 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+u64 btrfs_file_extent_length(struct btrfs_path *path)
+{
+        int extent_type;
+        struct btrfs_file_extent_item *fi;
+        u64 len;
+
+        fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                            struct btrfs_file_extent_item);
+        extent_type = btrfs_file_extent_type(path->nodes[0], fi);
+
+        if (extent_type == BTRFS_FILE_EXTENT_REG ||
+            extent_type == BTRFS_FILE_EXTENT_PREALLOC)
+                len = btrfs_file_extent_num_bytes(path->nodes[0], fi);
+        else if (extent_type == BTRFS_FILE_EXTENT_INLINE)
+                len = btrfs_file_extent_inline_len(path->nodes[0], fi);
+        else
+                BUG();
+
+        return len;
+}
 
 static int __btrfs_lookup_bio_sums(struct btrfs_root *root,
                                    struct inode *inode, struct bio *bio,
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index f6b40e86121b..77061bf43edb 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -39,7 +39,9 @@
 #include "tree-log.h"
 #include "locking.h"
 #include "compat.h"
+#include "volumes.h"
 
+static struct kmem_cache *btrfs_inode_defrag_cachep;
 /*
  * when auto defrag is enabled we
  * queue up these defrag structs to remember which
@@ -89,7 +91,7 @@ static int __compare_inode_defrag(struct inode_defrag *defrag1,
  * If an existing record is found the defrag item you
  * pass in is freed
  */
-static void __btrfs_add_inode_defrag(struct inode *inode,
+static int __btrfs_add_inode_defrag(struct inode *inode,
                                     struct inode_defrag *defrag)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -117,18 +119,24 @@ static void __btrfs_add_inode_defrag(struct inode *inode,
                                 entry->transid = defrag->transid;
                         if (defrag->last_offset > entry->last_offset)
                                 entry->last_offset = defrag->last_offset;
-                        goto exists;
+                        return -EEXIST;
                 }
         }
         set_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
         rb_link_node(&defrag->rb_node, parent, p);
         rb_insert_color(&defrag->rb_node, &root->fs_info->defrag_inodes);
-        return;
+        return 0;
+}
 
-exists:
-        kfree(defrag);
-        return;
+static inline int __need_auto_defrag(struct btrfs_root *root)
+{
+        if (!btrfs_test_opt(root, AUTO_DEFRAG))
+                return 0;
 
+        if (btrfs_fs_closing(root->fs_info))
+                return 0;
+
+        return 1;
 }
 
 /*
@@ -141,11 +149,9 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct inode_defrag *defrag;
         u64 transid;
+        int ret;
 
-        if (!btrfs_test_opt(root, AUTO_DEFRAG))
-                return 0;
-
-        if (btrfs_fs_closing(root->fs_info))
+        if (!__need_auto_defrag(root))
                 return 0;
 
         if (test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags))
@@ -156,7 +162,7 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
         else
                 transid = BTRFS_I(inode)->root->last_trans;
 
-        defrag = kzalloc(sizeof(*defrag), GFP_NOFS);
+        defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS);
         if (!defrag)
                 return -ENOMEM;
 
@@ -165,20 +171,56 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
         defrag->root = root->root_key.objectid;
 
         spin_lock(&root->fs_info->defrag_inodes_lock);
-        if (!test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags))
-                __btrfs_add_inode_defrag(inode, defrag);
-        else
-                kfree(defrag);
+        if (!test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) {
+                /*
+                 * If we set IN_DEFRAG flag and evict the inode from memory,
+                 * and then re-read this inode, this new inode doesn't have
+                 * IN_DEFRAG flag. At the case, we may find the existed defrag.
+                 */
+                ret = __btrfs_add_inode_defrag(inode, defrag);
+                if (ret)
+                        kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+        } else {
+                kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+        }
         spin_unlock(&root->fs_info->defrag_inodes_lock);
         return 0;
 }
 
 /*
- * must be called with the defrag_inodes lock held
+ * Requeue the defrag object. If there is a defrag object that points to
+ * the same inode in the tree, we will merge them together (by
+ * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
+ */
+void btrfs_requeue_inode_defrag(struct inode *inode,
+                                struct inode_defrag *defrag)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        if (!__need_auto_defrag(root))
+                goto out;
+
+        /*
+         * Here we don't check the IN_DEFRAG flag, because we need merge
+         * them together.
+         */
+        spin_lock(&root->fs_info->defrag_inodes_lock);
+        ret = __btrfs_add_inode_defrag(inode, defrag);
+        spin_unlock(&root->fs_info->defrag_inodes_lock);
+        if (ret)
+                goto out;
+        return;
+out:
+        kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+}
+
+/*
+ * pick the defragable inode that we want, if it doesn't exist, we will get
+ * the next one.
  */
-struct inode_defrag *btrfs_find_defrag_inode(struct btrfs_fs_info *info,
-                                             u64 root, u64 ino,
-                                             struct rb_node **next)
+static struct inode_defrag *
+btrfs_pick_defrag_inode(struct btrfs_fs_info *fs_info, u64 root, u64 ino)
 {
         struct inode_defrag *entry = NULL;
         struct inode_defrag tmp;
@@ -189,7 +231,8 @@ struct inode_defrag *btrfs_find_defrag_inode(struct btrfs_fs_info *info,
         tmp.ino = ino;
         tmp.root = root;
 
-        p = info->defrag_inodes.rb_node;
+        spin_lock(&fs_info->defrag_inodes_lock);
+        p = fs_info->defrag_inodes.rb_node;
         while (p) {
                 parent = p;
                 entry = rb_entry(parent, struct inode_defrag, rb_node);
@@ -200,52 +243,131 @@ struct inode_defrag *btrfs_find_defrag_inode(struct btrfs_fs_info *info,
                 else if (ret > 0)
                         p = parent->rb_right;
                 else
-                        return entry;
+                        goto out;
         }
 
-        if (next) {
-                while (parent && __compare_inode_defrag(&tmp, entry) > 0) {
-                        parent = rb_next(parent);
+        if (parent && __compare_inode_defrag(&tmp, entry) > 0) {
+                parent = rb_next(parent);
+                if (parent)
                         entry = rb_entry(parent, struct inode_defrag, rb_node);
-                }
-                *next = parent;
+                else
+                        entry = NULL;
         }
-        return NULL;
+out:
+        if (entry)
+                rb_erase(parent, &fs_info->defrag_inodes);
+        spin_unlock(&fs_info->defrag_inodes_lock);
+        return entry;
 }
 
-/*
- * run through the list of inodes in the FS that need
- * defragging
- */
-int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
+void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)
 {
         struct inode_defrag *defrag;
+        struct rb_node *node;
+
+        spin_lock(&fs_info->defrag_inodes_lock);
+        node = rb_first(&fs_info->defrag_inodes);
+        while (node) {
+                rb_erase(node, &fs_info->defrag_inodes);
+                defrag = rb_entry(node, struct inode_defrag, rb_node);
+                kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+
+                if (need_resched()) {
+                        spin_unlock(&fs_info->defrag_inodes_lock);
+                        cond_resched();
+                        spin_lock(&fs_info->defrag_inodes_lock);
+                }
+
+                node = rb_first(&fs_info->defrag_inodes);
+        }
+        spin_unlock(&fs_info->defrag_inodes_lock);
+}
+
+#define BTRFS_DEFRAG_BATCH      1024
+
+static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
+                                    struct inode_defrag *defrag)
+{
         struct btrfs_root *inode_root;
         struct inode *inode;
-        struct rb_node *n;
         struct btrfs_key key;
         struct btrfs_ioctl_defrag_range_args range;
-        u64 first_ino = 0;
-        u64 root_objectid = 0;
         int num_defrag;
-        int defrag_batch = 1024;
 
+        /* get the inode */
+        key.objectid = defrag->root;
+        btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
+        key.offset = (u64)-1;
+        inode_root = btrfs_read_fs_root_no_name(fs_info, &key);
+        if (IS_ERR(inode_root)) {
+                kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+                return PTR_ERR(inode_root);
+        }
+
+        key.objectid = defrag->ino;
+        btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
+        key.offset = 0;
+        inode = btrfs_iget(fs_info->sb, &key, inode_root, NULL);
+        if (IS_ERR(inode)) {
+                kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+                return PTR_ERR(inode);
+        }
+
+        /* do a chunk of defrag */
+        clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
         memset(&range, 0, sizeof(range));
         range.len = (u64)-1;
+        range.start = defrag->last_offset;
+
+        sb_start_write(fs_info->sb);
+        num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid,
+                                       BTRFS_DEFRAG_BATCH);
+        sb_end_write(fs_info->sb);
+        /*
+         * if we filled the whole defrag batch, there
+         * must be more work to do.  Queue this defrag
+         * again
+         */
+        if (num_defrag == BTRFS_DEFRAG_BATCH) {
+                defrag->last_offset = range.start;
+                btrfs_requeue_inode_defrag(inode, defrag);
+        } else if (defrag->last_offset && !defrag->cycled) {
+                /*
+                 * we didn't fill our defrag batch, but
+                 * we didn't start at zero.  Make sure we loop
+                 * around to the start of the file.
+                 */
+                defrag->last_offset = 0;
+                defrag->cycled = 1;
+                btrfs_requeue_inode_defrag(inode, defrag);
+        } else {
+                kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
+        }
+
+        iput(inode);
+        return 0;
+}
+
+/*
+ * run through the list of inodes in the FS that need
+ * defragging
+ */
+int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
+{
+        struct inode_defrag *defrag;
+        u64 first_ino = 0;
+        u64 root_objectid = 0;
 
         atomic_inc(&fs_info->defrag_running);
-        spin_lock(&fs_info->defrag_inodes_lock);
         while(1) {
-                n = NULL;
+                if (!__need_auto_defrag(fs_info->tree_root))
+                        break;
 
                 /* find an inode to defrag */
-                defrag = btrfs_find_defrag_inode(fs_info, root_objectid,
-                                                 first_ino, &n);
+                defrag = btrfs_pick_defrag_inode(fs_info, root_objectid,
+                                                 first_ino);
                 if (!defrag) {
-                        if (n) {
-                                defrag = rb_entry(n, struct inode_defrag,
-                                                  rb_node);
-                        } else if (root_objectid || first_ino) {
+                        if (root_objectid || first_ino) {
                                 root_objectid = 0;
                                 first_ino = 0;
                                 continue;
@@ -254,70 +376,11 @@ int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
                         }
                 }
 
-                /* remove it from the rbtree */
                 first_ino = defrag->ino + 1;
                 root_objectid = defrag->root;
-                rb_erase(&defrag->rb_node, &fs_info->defrag_inodes);
-
-                if (btrfs_fs_closing(fs_info))
-                        goto next_free;
 
-                spin_unlock(&fs_info->defrag_inodes_lock);
-
-                /* get the inode */
-                key.objectid = defrag->root;
-                btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
-                key.offset = (u64)-1;
-                inode_root = btrfs_read_fs_root_no_name(fs_info, &key);
-                if (IS_ERR(inode_root))
-                        goto next;
-
-                key.objectid = defrag->ino;
-                btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
-                key.offset = 0;
-
-                inode = btrfs_iget(fs_info->sb, &key, inode_root, NULL);
-                if (IS_ERR(inode))
-                        goto next;
-
-                /* do a chunk of defrag */
-                clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
-                range.start = defrag->last_offset;
-                num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid,
-                                               defrag_batch);
-                /*
-                 * if we filled the whole defrag batch, there
-                 * must be more work to do.  Queue this defrag
-                 * again
-                 */
-                if (num_defrag == defrag_batch) {
-                        defrag->last_offset = range.start;
-                        __btrfs_add_inode_defrag(inode, defrag);
-                        /*
-                         * we don't want to kfree defrag, we added it back to
-                         * the rbtree
-                         */
-                        defrag = NULL;
-                } else if (defrag->last_offset && !defrag->cycled) {
-                        /*
-                         * we didn't fill our defrag batch, but
-                         * we didn't start at zero.  Make sure we loop
-                         * around to the start of the file.
-                         */
-                        defrag->last_offset = 0;
-                        defrag->cycled = 1;
-                        __btrfs_add_inode_defrag(inode, defrag);
-                        defrag = NULL;
-                }
-
-                iput(inode);
-next:
-                spin_lock(&fs_info->defrag_inodes_lock);
-next_free:
-                kfree(defrag);
+                __btrfs_run_defrag_inode(fs_info, defrag);
         }
-        spin_unlock(&fs_info->defrag_inodes_lock);
-
         atomic_dec(&fs_info->defrag_running);
 
         /*
@@ -458,14 +521,15 @@ int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
  * this drops all the extents in the cache that intersect the range
  * [start, end].  Existing extents are split as required.
  */
-int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
-                            int skip_pinned)
+void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
+                             int skip_pinned)
 {
         struct extent_map *em;
         struct extent_map *split = NULL;
         struct extent_map *split2 = NULL;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         u64 len = end - start + 1;
+        u64 gen;
         int ret;
         int testend = 1;
         unsigned long flags;
@@ -477,11 +541,14 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 testend = 0;
         }
         while (1) {
+                int no_splits = 0;
+
                 if (!split)
                         split = alloc_extent_map();
                 if (!split2)
                         split2 = alloc_extent_map();
-                BUG_ON(!split || !split2); /* -ENOMEM */
+                if (!split || !split2)
+                        no_splits = 1;
 
                 write_lock(&em_tree->lock);
                 em = lookup_extent_mapping(em_tree, start, len);
@@ -490,6 +557,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         break;
                 }
                 flags = em->flags;
+                gen = em->generation;
                 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
                         if (testend && em->start + em->len >= start + len) {
                                 free_extent_map(em);
@@ -506,6 +574,8 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
                 remove_extent_mapping(em_tree, em);
+                if (no_splits)
+                        goto next;
 
                 if (em->block_start < EXTENT_MAP_LAST_BYTE &&
                     em->start < start) {
@@ -518,12 +588,15 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                                 split->block_len = em->block_len;
                         else
                                 split->block_len = split->len;
-
+                        split->orig_block_len = max(split->block_len,
+                                                    em->orig_block_len);
+                        split->generation = gen;
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
                         ret = add_extent_mapping(em_tree, split);
                         BUG_ON(ret); /* Logic error */
+                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = split2;
                         split2 = NULL;
@@ -537,6 +610,9 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
+                        split->generation = gen;
+                        split->orig_block_len = max(em->block_len,
+                                                    em->orig_block_len);
 
                         if (compressed) {
                                 split->block_len = em->block_len;
@@ -545,14 +621,16 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         } else {
                                 split->block_len = split->len;
                                 split->block_start = em->block_start + diff;
-                                split->orig_start = split->start;
+                                split->orig_start = em->orig_start;
                         }
 
                         ret = add_extent_mapping(em_tree, split);
                         BUG_ON(ret); /* Logic error */
+                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = NULL;
                 }
+next:
                 write_unlock(&em_tree->lock);
 
                 /* once for us */
@@ -564,7 +642,6 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 free_extent_map(split);
         if (split2)
                 free_extent_map(split2);
-        return 0;
 }
 
 /*
@@ -576,13 +653,13 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
  * it is either truncated or split.  Anything entirely inside the range
  * is deleted from the tree.
  */
-int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
-                       u64 start, u64 end, u64 *hint_byte, int drop_cache)
+int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                         struct btrfs_root *root, struct inode *inode,
+                         struct btrfs_path *path, u64 start, u64 end,
+                         u64 *drop_end, int drop_cache)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_buffer *leaf;
         struct btrfs_file_extent_item *fi;
-        struct btrfs_path *path;
         struct btrfs_key key;
         struct btrfs_key new_key;
         u64 ino = btrfs_ino(inode);
@@ -597,14 +674,12 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, struct inode *inode,
         int recow;
         int ret;
         int modify_tree = -1;
+        int update_refs = (root->ref_cows || root == root->fs_info->tree_root);
+        int found = 0;
 
         if (drop_cache)
                 btrfs_drop_extent_cache(inode, start, end - 1, 0);
 
-        path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
-
         if (start >= BTRFS_I(inode)->disk_i_size)
                 modify_tree = 0;
 
@@ -666,6 +741,7 @@ next_slot:
                         goto next_slot;
                 }
 
+                found = 1;
                 search_start = max(key.offset, start);
                 if (recow || !modify_tree) {
                         modify_tree = -1;
@@ -707,14 +783,13 @@ next_slot:
                                                         extent_end - start);
                         btrfs_mark_buffer_dirty(leaf);
 
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0) {
                                 ret = btrfs_inc_extent_ref(trans, root,
                                                 disk_bytenr, num_bytes, 0,
                                                 root->root_key.objectid,
                                                 new_key.objectid,
                                                 start - extent_offset, 0);
                                 BUG_ON(ret); /* -ENOMEM */
-                                *hint_byte = disk_bytenr;
                         }
                         key.offset = start;
                 }
@@ -734,10 +809,8 @@ next_slot:
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         extent_end - end);
                         btrfs_mark_buffer_dirty(leaf);
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0)
                                 inode_sub_bytes(inode, end - key.offset);
-                                *hint_byte = disk_bytenr;
-                        }
                         break;
                 }
 
@@ -753,10 +826,8 @@ next_slot:
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         start - key.offset);
                         btrfs_mark_buffer_dirty(leaf);
-                        if (disk_bytenr > 0) {
+                        if (update_refs && disk_bytenr > 0)
                                 inode_sub_bytes(inode, extent_end - start);
-                                *hint_byte = disk_bytenr;
-                        }
                         if (end == extent_end)
                                 break;
 
@@ -777,12 +848,13 @@ next_slot:
                                 del_nr++;
                         }
 
-                        if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                        if (update_refs &&
+                            extent_type == BTRFS_FILE_EXTENT_INLINE) {
                                 inode_sub_bytes(inode,
                                                 extent_end - key.offset);
                                 extent_end = ALIGN(extent_end,
                                                    root->sectorsize);
-                        } else if (disk_bytenr > 0) {
+                        } else if (update_refs && disk_bytenr > 0) {
                                 ret = btrfs_free_extent(trans, root,
                                                 disk_bytenr, num_bytes, 0,
                                                 root->root_key.objectid,
@@ -791,7 +863,6 @@ next_slot:
                                 BUG_ON(ret); /* -ENOMEM */
                                 inode_sub_bytes(inode,
                                                 extent_end - key.offset);
-                                *hint_byte = disk_bytenr;
                         }
 
                         if (end == extent_end)
@@ -806,7 +877,7 @@ next_slot:
                                               del_nr);
                         if (ret) {
                                 btrfs_abort_transaction(trans, root, ret);
-                                goto out;
+                                break;
                         }
 
                         del_nr = 0;
@@ -825,7 +896,24 @@ next_slot:
                         btrfs_abort_transaction(trans, root, ret);
         }
 
-out:
+        if (drop_end)
+                *drop_end = found ? min(end, extent_end) : end;
+        btrfs_release_path(path);
+        return ret;
+}
+
+int btrfs_drop_extents(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root, struct inode *inode, u64 start,
+                       u64 end, int drop_cache)
+{
+        struct btrfs_path *path;
+        int ret;
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+        ret = __btrfs_drop_extents(trans, root, inode, path, start, end, NULL,
+                                   drop_cache);
         btrfs_free_path(path);
         return ret;
 }
@@ -892,8 +980,6 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
         int ret;
         u64 ino = btrfs_ino(inode);
 
-        btrfs_drop_extent_cache(inode, start, end - 1, 0);
-
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
@@ -935,12 +1021,16 @@ again:
                         btrfs_set_item_key_safe(trans, root, path, &new_key);
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         extent_end - end);
                         btrfs_set_file_extent_offset(leaf, fi,
                                                      end - orig_offset);
                         fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         end - other_start);
                         btrfs_mark_buffer_dirty(leaf);
@@ -958,12 +1048,16 @@ again:
                                             struct btrfs_file_extent_item);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         start - key.offset);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         path->slots[0]++;
                         new_key.offset = start;
                         btrfs_set_item_key_safe(trans, root, path, &new_key);
 
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
+                        btrfs_set_file_extent_generation(leaf, fi,
+                                                         trans->transid);
                         btrfs_set_file_extent_num_bytes(leaf, fi,
                                                         other_end - start);
                         btrfs_set_file_extent_offset(leaf, fi,
@@ -991,12 +1085,14 @@ again:
                 leaf = path->nodes[0];
                 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
                                     struct btrfs_file_extent_item);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 split - key.offset);
 
                 fi = btrfs_item_ptr(leaf, path->slots[0],
                                     struct btrfs_file_extent_item);
 
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 extent_end - split);
@@ -1056,12 +1152,14 @@ again:
                            struct btrfs_file_extent_item);
                 btrfs_set_file_extent_type(leaf, fi,
                                            BTRFS_FILE_EXTENT_REG);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_mark_buffer_dirty(leaf);
         } else {
                 fi = btrfs_item_ptr(leaf, del_slot - 1,
                            struct btrfs_file_extent_item);
                 btrfs_set_file_extent_type(leaf, fi,
                                            BTRFS_FILE_EXTENT_REG);
+                btrfs_set_file_extent_generation(leaf, fi, trans->transid);
                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                 extent_end - key.offset);
                 btrfs_mark_buffer_dirty(leaf);
@@ -1173,8 +1271,8 @@ again:
 
                 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos,
                                   last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
-                                  EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
-                                  GFP_NOFS);
+                                  EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
+                                  0, 0, &cached_state, GFP_NOFS);
                 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
                                      start_pos, last_pos - 1, &cached_state,
                                      GFP_NOFS);
@@ -1314,10 +1412,9 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
 
                 cond_resched();
 
-                balance_dirty_pages_ratelimited_nr(inode->i_mapping,
-                                                   dirty_pages);
+                balance_dirty_pages_ratelimited(inode->i_mapping);
                 if (dirty_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
-                        btrfs_btree_balance_dirty(root, 1);
+                        btrfs_btree_balance_dirty(root);
 
                 pos += copied;
                 num_written += copied;
@@ -1366,6 +1463,24 @@ out:
         return written ? written : err;
 }
 
+static void update_time_for_write(struct inode *inode)
+{
+        struct timespec now;
+
+        if (IS_NOCMTIME(inode))
+                return;
+
+        now = current_fs_time(inode->i_sb);
+        if (!timespec_equal(&inode->i_mtime, &now))
+                inode->i_mtime = now;
+
+        if (!timespec_equal(&inode->i_ctime, &now))
+                inode->i_ctime = now;
+
+        if (IS_I_VERSION(inode))
+                inode_inc_iversion(inode);
+}
+
 static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                                     const struct iovec *iov,
                                     unsigned long nr_segs, loff_t pos)
@@ -1378,6 +1493,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
         ssize_t num_written = 0;
         ssize_t err = 0;
         size_t count, ocount;
+        bool sync = (file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host);
 
         sb_start_write(inode->i_sb);
 
@@ -1420,11 +1536,13 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 goto out;
         }
 
-        err = file_update_time(file);
-        if (err) {
-                mutex_unlock(&inode->i_mutex);
-                goto out;
-        }
+        /*
+         * We reserve space for updating the inode when we reserve space for the
+         * extent we are going to write, so we will enospc out there.  We don't
+         * need to start yet another transaction to update the inode as we will
+         * update the inode when we finish writing whatever data we write.
+         */
+        update_time_for_write(inode);
 
         start_pos = round_down(pos, root->sectorsize);
         if (start_pos > i_size_read(inode)) {
@@ -1435,6 +1553,9 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                 }
         }
 
+        if (sync)
+                atomic_inc(&BTRFS_I(inode)->sync_writers);
+
         if (unlikely(file->f_flags & O_DIRECT)) {
                 num_written = __btrfs_direct_write(iocb, iov, nr_segs,
                                                    pos, ppos, count, ocount);
@@ -1461,14 +1582,21 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
          * this will either be one more than the running transaction
          * or the generation used for the next transaction if there isn't
          * one running right now.
+         *
+         * We also have to set last_sub_trans to the current log transid,
+         * otherwise subsequent syncs to a file that's been synced in this
+         * transaction will appear to have already occured.
          */
         BTRFS_I(inode)->last_trans = root->fs_info->generation + 1;
+        BTRFS_I(inode)->last_sub_trans = root->log_transid;
         if (num_written > 0 || num_written == -EIOCBQUEUED) {
                 err = generic_write_sync(file, pos, num_written);
                 if (err < 0 && num_written > 0)
                         num_written = err;
         }
 out:
+        if (sync)
+                atomic_dec(&BTRFS_I(inode)->sync_writers);
         sb_end_write(inode->i_sb);
         current->backing_dev_info = NULL;
         return num_written ? num_written : err;
@@ -1514,16 +1642,26 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         trace_btrfs_sync_file(file, datasync);
 
+        /*
+         * We write the dirty pages in the range and wait until they complete
+         * out of the ->i_mutex. If so, we can flush the dirty pages by
+         * multi-task, and make the performance up.
+         */
+        atomic_inc(&BTRFS_I(inode)->sync_writers);
+        ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        atomic_dec(&BTRFS_I(inode)->sync_writers);
+        if (ret)
+                return ret;
+
         mutex_lock(&inode->i_mutex);
 
         /*
-         * we wait first, since the writeback may change the inode, also wait
-         * ordered range does a filemape_write_and_wait_range which is why we
-         * don't do it above like other file systems.
+         * We flush the dirty pages again to avoid some dirty pages in the
+         * range being left.
          */
-        root->log_batch++;
-        btrfs_wait_ordered_range(inode, start, end);
-        root->log_batch++;
+        atomic_inc(&root->log_batch);
+        btrfs_wait_ordered_range(inode, start, end - start + 1);
+        atomic_inc(&root->log_batch);
 
         /*
          * check the transaction that last modified this inode
@@ -1544,6 +1682,14 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
             BTRFS_I(inode)->last_trans <=
             root->fs_info->last_trans_committed) {
                 BTRFS_I(inode)->last_trans = 0;
+
+                /*
+                 * We'v had everything committed since the last time we were
+                 * modified so clear this flag in case it was set for whatever
+                 * reason, it's no longer relevant.
+                 */
+                clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                          &BTRFS_I(inode)->runtime_flags);
                 mutex_unlock(&inode->i_mutex);
                 goto out;
         }
@@ -1615,6 +1761,329 @@ static int btrfs_file_mmap(struct file	*filp, struct vm_area_struct *vma)
         return 0;
 }
 
+static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
+                          int slot, u64 start, u64 end)
+{
+        struct btrfs_file_extent_item *fi;
+        struct btrfs_key key;
+
+        if (slot < 0 || slot >= btrfs_header_nritems(leaf))
+                return 0;
+
+        btrfs_item_key_to_cpu(leaf, &key, slot);
+        if (key.objectid != btrfs_ino(inode) ||
+            key.type != BTRFS_EXTENT_DATA_KEY)
+                return 0;
+
+        fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+
+        if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
+                return 0;
+
+        if (btrfs_file_extent_disk_bytenr(leaf, fi))
+                return 0;
+
+        if (key.offset == end)
+                return 1;
+        if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
+                return 1;
+        return 0;
+}
+
+static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
+                      struct btrfs_path *path, u64 offset, u64 end)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct extent_buffer *leaf;
+        struct btrfs_file_extent_item *fi;
+        struct extent_map *hole_em;
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct btrfs_key key;
+        int ret;
+
+        key.objectid = btrfs_ino(inode);
+        key.type = BTRFS_EXTENT_DATA_KEY;
+        key.offset = offset;
+
+
+        ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
+        if (ret < 0)
+                return ret;
+        BUG_ON(!ret);
+
+        leaf = path->nodes[0];
+        if (hole_mergeable(inode, leaf, path->slots[0]-1, offset, end)) {
+                u64 num_bytes;
+
+                path->slots[0]--;
+                fi = btrfs_item_ptr(leaf, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
+                        end - offset;
+                btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_offset(leaf, fi, 0);
+                btrfs_mark_buffer_dirty(leaf);
+                goto out;
+        }
+
+        if (hole_mergeable(inode, leaf, path->slots[0]+1, offset, end)) {
+                u64 num_bytes;
+
+                path->slots[0]++;
+                key.offset = offset;
+                btrfs_set_item_key_safe(trans, root, path, &key);
+                fi = btrfs_item_ptr(leaf, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
+                        offset;
+                btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
+                btrfs_set_file_extent_offset(leaf, fi, 0);
+                btrfs_mark_buffer_dirty(leaf);
+                goto out;
+        }
+        btrfs_release_path(path);
+
+        ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset,
+                                       0, 0, end - offset, 0, end - offset,
+                                       0, 0, 0);
+        if (ret)
+                return ret;
+
+out:
+        btrfs_release_path(path);
+
+        hole_em = alloc_extent_map();
+        if (!hole_em) {
+                btrfs_drop_extent_cache(inode, offset, end - 1, 0);
+                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                        &BTRFS_I(inode)->runtime_flags);
+        } else {
+                hole_em->start = offset;
+                hole_em->len = end - offset;
+                hole_em->orig_start = offset;
+
+                hole_em->block_start = EXTENT_MAP_HOLE;
+                hole_em->block_len = 0;
+                hole_em->orig_block_len = 0;
+                hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
+                hole_em->compress_type = BTRFS_COMPRESS_NONE;
+                hole_em->generation = trans->transid;
+
+                do {
+                        btrfs_drop_extent_cache(inode, offset, end - 1, 0);
+                        write_lock(&em_tree->lock);
+                        ret = add_extent_mapping(em_tree, hole_em);
+                        if (!ret)
+                                list_move(&hole_em->list,
+                                          &em_tree->modified_extents);
+                        write_unlock(&em_tree->lock);
+                } while (ret == -EEXIST);
+                free_extent_map(hole_em);
+                if (ret)
+                        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                &BTRFS_I(inode)->runtime_flags);
+        }
+
+        return 0;
+}
+
+static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
+{
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct extent_state *cached_state = NULL;
+        struct btrfs_path *path;
+        struct btrfs_block_rsv *rsv;
+        struct btrfs_trans_handle *trans;
+        u64 lockstart = round_up(offset, BTRFS_I(inode)->root->sectorsize);
+        u64 lockend = round_down(offset + len,
+                                 BTRFS_I(inode)->root->sectorsize) - 1;
+        u64 cur_offset = lockstart;
+        u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
+        u64 drop_end;
+        int ret = 0;
+        int err = 0;
+        bool same_page = ((offset >> PAGE_CACHE_SHIFT) ==
+                          ((offset + len - 1) >> PAGE_CACHE_SHIFT));
+
+        btrfs_wait_ordered_range(inode, offset, len);
+
+        mutex_lock(&inode->i_mutex);
+        /*
+         * We needn't truncate any page which is beyond the end of the file
+         * because we are sure there is no data there.
+         */
+        /*
+         * Only do this if we are in the same page and we aren't doing the
+         * entire page.
+         */
+        if (same_page && len < PAGE_CACHE_SIZE) {
+                if (offset < round_up(inode->i_size, PAGE_CACHE_SIZE))
+                        ret = btrfs_truncate_page(inode, offset, len, 0);
+                mutex_unlock(&inode->i_mutex);
+                return ret;
+        }
+
+        /* zero back part of the first page */
+        if (offset < round_up(inode->i_size, PAGE_CACHE_SIZE)) {
+                ret = btrfs_truncate_page(inode, offset, 0, 0);
+                if (ret) {
+                        mutex_unlock(&inode->i_mutex);
+                        return ret;
+                }
+        }
+
+        /* zero the front end of the last page */
+        if (offset + len < round_up(inode->i_size, PAGE_CACHE_SIZE)) {
+                ret = btrfs_truncate_page(inode, offset + len, 0, 1);
+                if (ret) {
+                        mutex_unlock(&inode->i_mutex);
+                        return ret;
+                }
+        }
+
+        if (lockend < lockstart) {
+                mutex_unlock(&inode->i_mutex);
+                return 0;
+        }
+
+        while (1) {
+                struct btrfs_ordered_extent *ordered;
+
+                truncate_pagecache_range(inode, lockstart, lockend);
+
+                lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
+                                 0, &cached_state);
+                ordered = btrfs_lookup_first_ordered_extent(inode, lockend);
+
+                /*
+                 * We need to make sure we have no ordered extents in this range
+                 * and nobody raced in and read a page in this range, if we did
+                 * we need to try again.
+                 */
+                if ((!ordered ||
+                    (ordered->file_offset + ordered->len < lockstart ||
+                     ordered->file_offset > lockend)) &&
+                     !test_range_bit(&BTRFS_I(inode)->io_tree, lockstart,
+                                     lockend, EXTENT_UPTODATE, 0,
+                                     cached_state)) {
+                        if (ordered)
+                                btrfs_put_ordered_extent(ordered);
+                        break;
+                }
+                if (ordered)
+                        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,
+                                         lockend - lockstart + 1);
+        }
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
+        if (!rsv) {
+                ret = -ENOMEM;
+                goto out_free;
+        }
+        rsv->size = btrfs_calc_trunc_metadata_size(root, 1);
+        rsv->failfast = 1;
+
+        /*
+         * 1 - update the inode
+         * 1 - removing the extents in the range
+         * 1 - adding the hole extent
+         */
+        trans = btrfs_start_transaction(root, 3);
+        if (IS_ERR(trans)) {
+                err = PTR_ERR(trans);
+                goto out_free;
+        }
+
+        ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
+                                      min_size);
+        BUG_ON(ret);
+        trans->block_rsv = rsv;
+
+        while (cur_offset < lockend) {
+                ret = __btrfs_drop_extents(trans, root, inode, path,
+                                           cur_offset, lockend + 1,
+                                           &drop_end, 1);
+                if (ret != -ENOSPC)
+                        break;
+
+                trans->block_rsv = &root->fs_info->trans_block_rsv;
+
+                ret = fill_holes(trans, inode, path, cur_offset, drop_end);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
+
+                cur_offset = drop_end;
+
+                ret = btrfs_update_inode(trans, root, inode);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
+
+                btrfs_end_transaction(trans, root);
+                btrfs_btree_balance_dirty(root);
+
+                trans = btrfs_start_transaction(root, 3);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        trans = NULL;
+                        break;
+                }
+
+                ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
+                                              rsv, min_size);
+                BUG_ON(ret);    /* shouldn't happen */
+                trans->block_rsv = rsv;
+        }
+
+        if (ret) {
+                err = ret;
+                goto out_trans;
+        }
+
+        trans->block_rsv = &root->fs_info->trans_block_rsv;
+        ret = fill_holes(trans, inode, path, cur_offset, drop_end);
+        if (ret) {
+                err = ret;
+                goto out_trans;
+        }
+
+out_trans:
+        if (!trans)
+                goto out_free;
+
+        inode_inc_iversion(inode);
+        inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+
+        trans->block_rsv = &root->fs_info->trans_block_rsv;
+        ret = btrfs_update_inode(trans, root, inode);
+        btrfs_end_transaction(trans, root);
+        btrfs_btree_balance_dirty(root);
+out_free:
+        btrfs_free_path(path);
+        btrfs_free_block_rsv(root, rsv);
+out:
+        unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
+                             &cached_state, GFP_NOFS);
+        mutex_unlock(&inode->i_mutex);
+        if (ret && !err)
+                err = ret;
+        return err;
+}
+
 static long btrfs_fallocate(struct file *file, int mode,
                             loff_t offset, loff_t len)
 {
@@ -1626,22 +2095,25 @@ static long btrfs_fallocate(struct file *file, int mode,
         u64 alloc_end;
         u64 alloc_hint = 0;
         u64 locked_end;
-        u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
         struct extent_map *em;
+        int blocksize = BTRFS_I(inode)->root->sectorsize;
         int ret;
 
-        alloc_start = offset & ~mask;
-        alloc_end =  (offset + len + mask) & ~mask;
+        alloc_start = round_down(offset, blocksize);
+        alloc_end = round_up(offset + len, blocksize);
 
-        /* We only support the FALLOC_FL_KEEP_SIZE mode */
-        if (mode & ~FALLOC_FL_KEEP_SIZE)
+        /* Make sure we aren't being give some crap mode */
+        if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
 
+        if (mode & FALLOC_FL_PUNCH_HOLE)
+                return btrfs_punch_hole(inode, offset, len);
+
         /*
          * Make sure we have enough space before we do the
          * allocation.
          */
-        ret = btrfs_check_data_free_space(inode, len);
+        ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);
         if (ret)
                 return ret;
 
@@ -1709,7 +2181,7 @@ static long btrfs_fallocate(struct file *file, int mode,
                 }
                 last_byte = min(extent_map_end(em), alloc_end);
                 actual_end = min_t(u64, extent_map_end(em), offset + len);
-                last_byte = (last_byte + mask) & ~mask;
+                last_byte = ALIGN(last_byte, blocksize);
 
                 if (em->block_start == EXTENT_MAP_HOLE ||
                     (cur_offset >= inode->i_size &&
@@ -1748,11 +2220,11 @@ static long btrfs_fallocate(struct file *file, int mode,
 out:
         mutex_unlock(&inode->i_mutex);
         /* Let go of our reservation. */
-        btrfs_free_reserved_data_space(inode, len);
+        btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);
         return ret;
 }
 
-static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
+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;
@@ -1786,7 +2258,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
          * before the position we want in case there is outstanding delalloc
          * going on here.
          */
-        if (origin == SEEK_HOLE && start != 0) {
+        if (whence == SEEK_HOLE && start != 0) {
                 if (start <= root->sectorsize)
                         em = btrfs_get_extent_fiemap(inode, NULL, 0, 0,
                                                      root->sectorsize, 0);
@@ -1820,13 +2292,13 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin)
                                 }
                         }
 
-                        if (origin == SEEK_HOLE) {
+                        if (whence == SEEK_HOLE) {
                                 *offset = start;
                                 free_extent_map(em);
                                 break;
                         }
                 } else {
-                        if (origin == SEEK_DATA) {
+                        if (whence == SEEK_DATA) {
                                 if (em->block_start == EXTENT_MAP_DELALLOC) {
                                         if (start >= inode->i_size) {
                                                 free_extent_map(em);
@@ -1863,16 +2335,16 @@ out:
         return ret;
 }
 
-static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int origin)
+static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
 {
         struct inode *inode = file->f_mapping->host;
         int ret;
 
         mutex_lock(&inode->i_mutex);
-        switch (origin) {
+        switch (whence) {
         case SEEK_END:
         case SEEK_CUR:
-                offset = generic_file_llseek(file, offset, origin);
+                offset = generic_file_llseek(file, offset, whence);
                 goto out;
         case SEEK_DATA:
         case SEEK_HOLE:
@@ -1881,7 +2353,7 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int origin)
                         return -ENXIO;
                 }
 
-                ret = find_desired_extent(inode, &offset, origin);
+                ret = find_desired_extent(inode, &offset, whence);
                 if (ret) {
                         mutex_unlock(&inode->i_mutex);
                         return ret;
@@ -1924,3 +2396,21 @@ const struct file_operations btrfs_file_operations = {
         .compat_ioctl   = btrfs_ioctl,
 #endif
 };
+
+void btrfs_auto_defrag_exit(void)
+{
+        if (btrfs_inode_defrag_cachep)
+                kmem_cache_destroy(btrfs_inode_defrag_cachep);
+}
+
+int btrfs_auto_defrag_init(void)
+{
+        btrfs_inode_defrag_cachep = kmem_cache_create("btrfs_inode_defrag",
+                                        sizeof(struct inode_defrag), 0,
+                                        SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                                        NULL);
+        if (!btrfs_inode_defrag_cachep)
+                return -ENOMEM;
+
+        return 0;
+}
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 6b10acfc2f5c..59ea2e4349c9 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -307,7 +307,6 @@ static void io_ctl_unmap_page(struct io_ctl *io_ctl)
 
 static void io_ctl_map_page(struct io_ctl *io_ctl, int clear)
 {
-        WARN_ON(io_ctl->cur);
         BUG_ON(io_ctl->index >= io_ctl->num_pages);
         io_ctl->page = io_ctl->pages[io_ctl->index++];
         io_ctl->cur = kmap(io_ctl->page);
@@ -966,7 +965,7 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
                                block_group->key.offset)) {
                 ret = find_first_extent_bit(unpin, start,
                                             &extent_start, &extent_end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
                 if (ret) {
                         ret = 0;
                         break;
@@ -1250,18 +1249,13 @@ tree_search_offset(struct btrfs_free_space_ctl *ctl,
                          * if previous extent entry covers the offset,
                          * we should return it instead of the bitmap entry
                          */
-                        n = &entry->offset_index;
-                        while (1) {
-                                n = rb_prev(n);
-                                if (!n)
-                                        break;
+                        n = rb_prev(&entry->offset_index);
+                        if (n) {
                                 prev = rb_entry(n, struct btrfs_free_space,
                                                 offset_index);
-                                if (!prev->bitmap) {
-                                        if (prev->offset + prev->bytes > offset)
-                                                entry = prev;
-                                        break;
-                                }
+                                if (!prev->bitmap &&
+                                    prev->offset + prev->bytes > offset)
+                                        entry = prev;
                         }
                 }
                 return entry;
@@ -1287,18 +1281,13 @@ tree_search_offset(struct btrfs_free_space_ctl *ctl,
         }
 
         if (entry->bitmap) {
-                n = &entry->offset_index;
-                while (1) {
-                        n = rb_prev(n);
-                        if (!n)
-                                break;
+                n = rb_prev(&entry->offset_index);
+                if (n) {
                         prev = rb_entry(n, struct btrfs_free_space,
                                         offset_index);
-                        if (!prev->bitmap) {
-                                if (prev->offset + prev->bytes > offset)
-                                        return prev;
-                                break;
-                        }
+                        if (!prev->bitmap &&
+                            prev->offset + prev->bytes > offset)
+                                return prev;
                 }
                 if (entry->offset + BITS_PER_BITMAP * ctl->unit > offset)
                         return entry;
@@ -1364,7 +1353,7 @@ static void recalculate_thresholds(struct btrfs_free_space_ctl *ctl)
         u64 bitmap_bytes;
         u64 extent_bytes;
         u64 size = block_group->key.offset;
-        u64 bytes_per_bg = BITS_PER_BITMAP * block_group->sectorsize;
+        u64 bytes_per_bg = BITS_PER_BITMAP * ctl->unit;
         int max_bitmaps = div64_u64(size + bytes_per_bg - 1, bytes_per_bg);
 
         BUG_ON(ctl->total_bitmaps > max_bitmaps);
@@ -1454,9 +1443,7 @@ static int search_bitmap(struct btrfs_free_space_ctl *ctl,
                           max_t(u64, *offset, bitmap_info->offset));
         bits = bytes_to_bits(*bytes, ctl->unit);
 
-        for (i = find_next_bit(bitmap_info->bitmap, BITS_PER_BITMAP, i);
-             i < BITS_PER_BITMAP;
-             i = find_next_bit(bitmap_info->bitmap, BITS_PER_BITMAP, i + 1)) {
+        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) {
@@ -1652,8 +1639,7 @@ static bool use_bitmap(struct btrfs_free_space_ctl *ctl,
          * some block groups are so tiny they can't be enveloped by a bitmap, so
          * don't even bother to create a bitmap for this
          */
-        if (BITS_PER_BITMAP * block_group->sectorsize >
-            block_group->key.offset)
+        if (BITS_PER_BITMAP * ctl->unit > block_group->key.offset)
                 return false;
 
         return true;
@@ -2300,16 +2286,14 @@ static int btrfs_bitmap_cluster(struct btrfs_block_group_cache *block_group,
         unsigned long total_found = 0;
         int ret;
 
-        i = offset_to_bit(entry->offset, block_group->sectorsize,
+        i = offset_to_bit(entry->offset, ctl->unit,
                           max_t(u64, offset, entry->offset));
-        want_bits = bytes_to_bits(bytes, block_group->sectorsize);
-        min_bits = bytes_to_bits(min_bytes, block_group->sectorsize);
+        want_bits = bytes_to_bits(bytes, ctl->unit);
+        min_bits = bytes_to_bits(min_bytes, ctl->unit);
 
 again:
         found_bits = 0;
-        for (i = find_next_bit(entry->bitmap, BITS_PER_BITMAP, i);
-             i < BITS_PER_BITMAP;
-             i = find_next_bit(entry->bitmap, BITS_PER_BITMAP, i + 1)) {
+        for_each_set_bit_from(i, entry->bitmap, BITS_PER_BITMAP) {
                 next_zero = find_next_zero_bit(entry->bitmap,
                                                BITS_PER_BITMAP, i);
                 if (next_zero - i >= min_bits) {
@@ -2329,23 +2313,22 @@ again:
 
         total_found += found_bits;
 
-        if (cluster->max_size < found_bits * block_group->sectorsize)
-                cluster->max_size = found_bits * block_group->sectorsize;
+        if (cluster->max_size < found_bits * ctl->unit)
+                cluster->max_size = found_bits * ctl->unit;
 
         if (total_found < want_bits || cluster->max_size < cont1_bytes) {
                 i = next_zero + 1;
                 goto again;
         }
 
-        cluster->window_start = start * block_group->sectorsize +
-                entry->offset;
+        cluster->window_start = start * ctl->unit + entry->offset;
         rb_erase(&entry->offset_index, &ctl->free_space_offset);
         ret = tree_insert_offset(&cluster->root, entry->offset,
                                  &entry->offset_index, 1);
         BUG_ON(ret); /* -EEXIST; Logic error */
 
         trace_btrfs_setup_cluster(block_group, cluster,
-                                  total_found * block_group->sectorsize, 1);
+                                  total_found * ctl->unit, 1);
         return 0;
 }
 
diff --git a/fs/btrfs/hash.h b/fs/btrfs/hash.h
index db2ff9773b99..1d982812ab67 100644
--- a/fs/btrfs/hash.h
+++ b/fs/btrfs/hash.h
@@ -24,4 +24,14 @@ static inline u64 btrfs_name_hash(const char *name, int len)
 {
         return crc32c((u32)~1, name, len);
 }
+
+/*
+ * Figure the key offset of an extended inode ref
+ */
+static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,
+                                    int len)
+{
+        return (u64) crc32c(parent_objectid, name, len);
+}
+
 #endif
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index a13cf1a96c73..48b8fda93132 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -18,6 +18,7 @@
 
 #include "ctree.h"
 #include "disk-io.h"
+#include "hash.h"
 #include "transaction.h"
 #include "print-tree.h"
 
@@ -50,18 +51,57 @@ static int find_name_in_backref(struct btrfs_path *path, const char *name,
         return 0;
 }
 
-struct btrfs_inode_ref *
+int btrfs_find_name_in_ext_backref(struct btrfs_path *path, u64 ref_objectid,
+                                   const char *name, int name_len,
+                                   struct btrfs_inode_extref **extref_ret)
+{
+        struct extent_buffer *leaf;
+        struct btrfs_inode_extref *extref;
+        unsigned long ptr;
+        unsigned long name_ptr;
+        u32 item_size;
+        u32 cur_offset = 0;
+        int ref_name_len;
+
+        leaf = path->nodes[0];
+        item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+        ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+        /*
+         * Search all extended backrefs in this item. We're only
+         * looking through any collisions so most of the time this is
+         * just going to compare against one buffer. If all is well,
+         * we'll return success and the inode ref object.
+         */
+        while (cur_offset < item_size) {
+                extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
+                name_ptr = (unsigned long)(&extref->name);
+                ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                if (ref_name_len == name_len &&
+                    btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&
+                    (memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)) {
+                        if (extref_ret)
+                                *extref_ret = extref;
+                        return 1;
+                }
+
+                cur_offset += ref_name_len + sizeof(*extref);
+        }
+        return 0;
+}
+
+static struct btrfs_inode_ref *
 btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root,
-                        struct btrfs_path *path,
-                        const char *name, int name_len,
-                        u64 inode_objectid, u64 ref_objectid, int mod)
+                       struct btrfs_root *root,
+                       struct btrfs_path *path,
+                       const char *name, int name_len,
+                       u64 inode_objectid, u64 ref_objectid, int ins_len,
+                       int cow)
 {
+        int ret;
         struct btrfs_key key;
         struct btrfs_inode_ref *ref;
-        int ins_len = mod < 0 ? -1 : 0;
-        int cow = mod != 0;
-        int ret;
 
         key.objectid = inode_objectid;
         key.type = BTRFS_INODE_REF_KEY;
@@ -77,13 +117,150 @@ btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans,
         return ref;
 }
 
-int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
+/* Returns NULL if no extref found */
+struct btrfs_inode_extref *
+btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *root,
+                          struct btrfs_path *path,
+                          const char *name, int name_len,
+                          u64 inode_objectid, u64 ref_objectid, int ins_len,
+                          int cow)
+{
+        int ret;
+        struct btrfs_key key;
+        struct btrfs_inode_extref *extref;
+
+        key.objectid = inode_objectid;
+        key.type = BTRFS_INODE_EXTREF_KEY;
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
+        if (ret < 0)
+                return ERR_PTR(ret);
+        if (ret > 0)
+                return NULL;
+        if (!btrfs_find_name_in_ext_backref(path, ref_objectid, name, name_len, &extref))
+                return NULL;
+        return extref;
+}
+
+int btrfs_get_inode_ref_index(struct btrfs_trans_handle *trans,
+                              struct btrfs_root *root,
+                              struct btrfs_path *path,
+                              const char *name, int name_len,
+                              u64 inode_objectid, u64 ref_objectid, int mod,
+                              u64 *ret_index)
+{
+        struct btrfs_inode_ref *ref;
+        struct btrfs_inode_extref *extref;
+        int ins_len = mod < 0 ? -1 : 0;
+        int cow = mod != 0;
+
+        ref = btrfs_lookup_inode_ref(trans, root, path, name, name_len,
+                                     inode_objectid, ref_objectid, ins_len,
+                                     cow);
+        if (IS_ERR(ref))
+                return PTR_ERR(ref);
+
+        if (ref != NULL) {
+                *ret_index = btrfs_inode_ref_index(path->nodes[0], ref);
+                return 0;
+        }
+
+        btrfs_release_path(path);
+
+        extref = btrfs_lookup_inode_extref(trans, root, path, name,
+                                           name_len, inode_objectid,
+                                           ref_objectid, ins_len, cow);
+        if (IS_ERR(extref))
+                return PTR_ERR(extref);
+
+        if (extref) {
+                *ret_index = btrfs_inode_extref_index(path->nodes[0], extref);
+                return 0;
+        }
+
+        return -ENOENT;
+}
+
+int btrfs_del_inode_extref(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            const char *name, int name_len,
                            u64 inode_objectid, u64 ref_objectid, u64 *index)
 {
         struct btrfs_path *path;
         struct btrfs_key key;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
+        int ret;
+        int del_len = name_len + sizeof(*extref);
+        unsigned long ptr;
+        unsigned long item_start;
+        u32 item_size;
+
+        key.objectid = inode_objectid;
+        btrfs_set_key_type(&key, BTRFS_INODE_EXTREF_KEY);
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        path->leave_spinning = 1;
+
+        ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
+        if (ret > 0)
+                ret = -ENOENT;
+        if (ret < 0)
+                goto out;
+
+        /*
+         * Sanity check - did we find the right item for this name?
+         * This should always succeed so error here will make the FS
+         * readonly.
+         */
+        if (!btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                            name, name_len, &extref)) {
+                btrfs_std_error(root->fs_info, -ENOENT);
+                ret = -EROFS;
+                goto out;
+        }
+
+        leaf = path->nodes[0];
+        item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+        if (index)
+                *index = btrfs_inode_extref_index(leaf, extref);
+
+        if (del_len == item_size) {
+                /*
+                 * Common case only one ref in the item, remove the
+                 * whole item.
+                 */
+                ret = btrfs_del_item(trans, root, path);
+                goto out;
+        }
+
+        ptr = (unsigned long)extref;
+        item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+        memmove_extent_buffer(leaf, ptr, ptr + del_len,
+                              item_size - (ptr + del_len - item_start));
+
+        btrfs_truncate_item(trans, root, path, item_size - del_len, 1);
+
+out:
+        btrfs_free_path(path);
+
+        return ret;
+}
+
+int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
+                        struct btrfs_root *root,
+                        const char *name, int name_len,
+                        u64 inode_objectid, u64 ref_objectid, u64 *index)
+{
+        struct btrfs_path *path;
+        struct btrfs_key key;
         struct btrfs_inode_ref *ref;
         struct extent_buffer *leaf;
         unsigned long ptr;
@@ -91,6 +268,7 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         u32 item_size;
         u32 sub_item_len;
         int ret;
+        int search_ext_refs = 0;
         int del_len = name_len + sizeof(*ref);
 
         key.objectid = inode_objectid;
@@ -106,12 +284,14 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
         if (ret > 0) {
                 ret = -ENOENT;
+                search_ext_refs = 1;
                 goto out;
         } else if (ret < 0) {
                 goto out;
         }
         if (!find_name_in_backref(path, name, name_len, &ref)) {
                 ret = -ENOENT;
+                search_ext_refs = 1;
                 goto out;
         }
         leaf = path->nodes[0];
@@ -129,8 +309,78 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans,
         item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
         memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
                               item_size - (ptr + sub_item_len - item_start));
-        btrfs_truncate_item(trans, root, path,
-                                  item_size - sub_item_len, 1);
+        btrfs_truncate_item(trans, root, path, item_size - sub_item_len, 1);
+out:
+        btrfs_free_path(path);
+
+        if (search_ext_refs) {
+                /*
+                 * No refs were found, or we could not find the
+                 * name in our ref array. Find and remove the extended
+                 * inode ref then.
+                 */
+                return btrfs_del_inode_extref(trans, root, name, name_len,
+                                              inode_objectid, ref_objectid, index);
+        }
+
+        return ret;
+}
+
+/*
+ * btrfs_insert_inode_extref() - Inserts an extended inode ref into a tree.
+ *
+ * The caller must have checked against BTRFS_LINK_MAX already.
+ */
+static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans,
+                                     struct btrfs_root *root,
+                                     const char *name, int name_len,
+                                     u64 inode_objectid, u64 ref_objectid, u64 index)
+{
+        struct btrfs_inode_extref *extref;
+        int ret;
+        int ins_len = name_len + sizeof(*extref);
+        unsigned long ptr;
+        struct btrfs_path *path;
+        struct btrfs_key key;
+        struct extent_buffer *leaf;
+        struct btrfs_item *item;
+
+        key.objectid = inode_objectid;
+        key.type = BTRFS_INODE_EXTREF_KEY;
+        key.offset = btrfs_extref_hash(ref_objectid, name, name_len);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        path->leave_spinning = 1;
+        ret = btrfs_insert_empty_item(trans, root, path, &key,
+                                      ins_len);
+        if (ret == -EEXIST) {
+                if (btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                                   name, name_len, NULL))
+                        goto out;
+
+                btrfs_extend_item(trans, root, path, ins_len);
+                ret = 0;
+        }
+        if (ret < 0)
+                goto out;
+
+        leaf = path->nodes[0];
+        item = btrfs_item_nr(leaf, 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;
+
+        btrfs_set_inode_extref_name_len(path->nodes[0], extref, name_len);
+        btrfs_set_inode_extref_index(path->nodes[0], extref, index);
+        btrfs_set_inode_extref_parent(path->nodes[0], extref, ref_objectid);
+
+        ptr = (unsigned long)&extref->name;
+        write_extent_buffer(path->nodes[0], name, ptr, name_len);
+        btrfs_mark_buffer_dirty(path->nodes[0]);
+
 out:
         btrfs_free_path(path);
         return ret;
@@ -191,6 +441,19 @@ int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans,
 
 out:
         btrfs_free_path(path);
+
+        if (ret == -EMLINK) {
+                struct btrfs_super_block *disk_super = root->fs_info->super_copy;
+                /* We ran out of space in the ref array. Need to
+                 * add an extended ref. */
+                if (btrfs_super_incompat_flags(disk_super)
+                    & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
+                        ret = btrfs_insert_inode_extref(trans, root, name,
+                                                        name_len,
+                                                        inode_objectid,
+                                                        ref_objectid, index);
+        }
+
         return ret;
 }
 
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c
index b1a1c929ba80..d26f67a59e36 100644
--- a/fs/btrfs/inode-map.c
+++ b/fs/btrfs/inode-map.c
@@ -434,8 +434,9 @@ int btrfs_save_ino_cache(struct btrfs_root *root,
          * 3 items for pre-allocation
          */
         trans->bytes_reserved = btrfs_calc_trans_metadata_size(root, 8);
-        ret = btrfs_block_rsv_add_noflush(root, trans->block_rsv,
-                                          trans->bytes_reserved);
+        ret = btrfs_block_rsv_add(root, trans->block_rsv,
+                                  trans->bytes_reserved,
+                                  BTRFS_RESERVE_NO_FLUSH);
         if (ret)
                 goto out;
         trace_btrfs_space_reservation(root->fs_info, "ino_cache",
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a6ed6944e50c..67ed24ae86bb 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -71,6 +71,7 @@ static const struct file_operations btrfs_dir_file_operations;
 static struct extent_io_ops btrfs_extent_io_ops;
 
 static struct kmem_cache *btrfs_inode_cachep;
+static struct kmem_cache *btrfs_delalloc_work_cachep;
 struct kmem_cache *btrfs_trans_handle_cachep;
 struct kmem_cache *btrfs_transaction_cachep;
 struct kmem_cache *btrfs_path_cachep;
@@ -94,8 +95,10 @@ static noinline int cow_file_range(struct inode *inode,
                                    struct page *locked_page,
                                    u64 start, u64 end, int *page_started,
                                    unsigned long *nr_written, int unlock);
-static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root, struct inode *inode);
+static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
+                                           u64 len, u64 orig_start,
+                                           u64 block_start, u64 block_len,
+                                           u64 orig_block_len, int type);
 
 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
                                      struct inode *inode,  struct inode *dir,
@@ -230,7 +233,6 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
         u64 inline_len = actual_end - start;
         u64 aligned_end = (end + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
-        u64 hint_byte;
         u64 data_len = inline_len;
         int ret;
 
@@ -247,8 +249,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                 return 1;
         }
 
-        ret = btrfs_drop_extents(trans, inode, start, aligned_end,
-                                 &hint_byte, 1);
+        ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
         if (ret)
                 return ret;
 
@@ -664,7 +665,7 @@ retry:
                                            async_extent->compressed_size,
                                            async_extent->compressed_size,
                                            0, alloc_hint, &ins, 1);
-                        if (ret)
+                        if (ret && ret != -ENOSPC)
                                 btrfs_abort_transaction(trans, root, ret);
                         btrfs_end_transaction(trans, root);
                 }
@@ -702,14 +703,19 @@ retry:
 
                 em->block_start = ins.objectid;
                 em->block_len = ins.offset;
+                em->orig_block_len = ins.offset;
                 em->bdev = root->fs_info->fs_devices->latest_bdev;
                 em->compress_type = async_extent->compress_type;
                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
                 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+                em->generation = -1;
 
                 while (1) {
                         write_lock(&em_tree->lock);
                         ret = add_extent_mapping(em_tree, em);
+                        if (!ret)
+                                list_move(&em->list,
+                                          &em_tree->modified_extents);
                         write_unlock(&em_tree->lock);
                         if (ret != -EEXIST) {
                                 free_extent_map(em);
@@ -807,14 +813,14 @@ static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
  * required to start IO on it.  It may be clean and already done with
  * IO when we return.
  */
-static noinline int cow_file_range(struct inode *inode,
-                                   struct page *locked_page,
-                                   u64 start, u64 end, int *page_started,
-                                   unsigned long *nr_written,
-                                   int unlock)
+static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
+                                     struct inode *inode,
+                                     struct btrfs_root *root,
+                                     struct page *locked_page,
+                                     u64 start, u64 end, int *page_started,
+                                     unsigned long *nr_written,
+                                     int unlock)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
         u64 alloc_hint = 0;
         u64 num_bytes;
         unsigned long ram_size;
@@ -827,25 +833,10 @@ static noinline int cow_file_range(struct inode *inode,
         int ret = 0;
 
         BUG_ON(btrfs_is_free_space_inode(inode));
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans)) {
-                extent_clear_unlock_delalloc(inode,
-                             &BTRFS_I(inode)->io_tree,
-                             start, end, locked_page,
-                             EXTENT_CLEAR_UNLOCK_PAGE |
-                             EXTENT_CLEAR_UNLOCK |
-                             EXTENT_CLEAR_DELALLOC |
-                             EXTENT_CLEAR_DIRTY |
-                             EXTENT_SET_WRITEBACK |
-                             EXTENT_END_WRITEBACK);
-                return PTR_ERR(trans);
-        }
-        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
         num_bytes = max(blocksize,  num_bytes);
         disk_num_bytes = num_bytes;
-        ret = 0;
 
         /* if this is a small write inside eof, kick off defrag */
         if (num_bytes < 64 * 1024 &&
@@ -904,12 +895,17 @@ static noinline int cow_file_range(struct inode *inode,
 
                 em->block_start = ins.objectid;
                 em->block_len = ins.offset;
+                em->orig_block_len = ins.offset;
                 em->bdev = root->fs_info->fs_devices->latest_bdev;
                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
+                em->generation = -1;
 
                 while (1) {
                         write_lock(&em_tree->lock);
                         ret = add_extent_mapping(em_tree, em);
+                        if (!ret)
+                                list_move(&em->list,
+                                          &em_tree->modified_extents);
                         write_unlock(&em_tree->lock);
                         if (ret != -EEXIST) {
                                 free_extent_map(em);
@@ -956,11 +952,9 @@ static noinline int cow_file_range(struct inode *inode,
                 alloc_hint = ins.objectid + ins.offset;
                 start += cur_alloc_size;
         }
-        ret = 0;
 out:
-        btrfs_end_transaction(trans, root);
-
         return ret;
+
 out_unlock:
         extent_clear_unlock_delalloc(inode,
                      &BTRFS_I(inode)->io_tree,
@@ -975,6 +969,39 @@ out_unlock:
         goto out;
 }
 
+static noinline int cow_file_range(struct inode *inode,
+                                   struct page *locked_page,
+                                   u64 start, u64 end, int *page_started,
+                                   unsigned long *nr_written,
+                                   int unlock)
+{
+        struct btrfs_trans_handle *trans;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans)) {
+                extent_clear_unlock_delalloc(inode,
+                             &BTRFS_I(inode)->io_tree,
+                             start, end, locked_page,
+                             EXTENT_CLEAR_UNLOCK_PAGE |
+                             EXTENT_CLEAR_UNLOCK |
+                             EXTENT_CLEAR_DELALLOC |
+                             EXTENT_CLEAR_DIRTY |
+                             EXTENT_SET_WRITEBACK |
+                             EXTENT_END_WRITEBACK);
+                return PTR_ERR(trans);
+        }
+        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
+
+        ret = __cow_file_range(trans, inode, root, locked_page, start, end,
+                               page_started, nr_written, unlock);
+
+        btrfs_end_transaction(trans, root);
+
+        return ret;
+}
+
 /*
  * work queue call back to started compression on a file and pages
  */
@@ -1130,6 +1157,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         u64 extent_offset;
         u64 disk_bytenr;
         u64 num_bytes;
+        u64 disk_num_bytes;
         int extent_type;
         int ret, err;
         int type;
@@ -1232,6 +1260,8 @@ next_slot:
                         extent_offset = btrfs_file_extent_offset(leaf, fi);
                         extent_end = found_key.offset +
                                 btrfs_file_extent_num_bytes(leaf, fi);
+                        disk_num_bytes =
+                                btrfs_file_extent_disk_num_bytes(leaf, fi);
                         if (extent_end <= start) {
                                 path->slots[0]++;
                                 goto next_slot;
@@ -1285,9 +1315,9 @@ out_check:
 
                 btrfs_release_path(path);
                 if (cow_start != (u64)-1) {
-                        ret = cow_file_range(inode, locked_page, cow_start,
-                                        found_key.offset - 1, page_started,
-                                        nr_written, 1);
+                        ret = __cow_file_range(trans, inode, root, locked_page,
+                                               cow_start, found_key.offset - 1,
+                                               page_started, nr_written, 1);
                         if (ret) {
                                 btrfs_abort_transaction(trans, root, ret);
                                 goto error;
@@ -1302,15 +1332,21 @@ out_check:
                         em = alloc_extent_map();
                         BUG_ON(!em); /* -ENOMEM */
                         em->start = cur_offset;
-                        em->orig_start = em->start;
+                        em->orig_start = found_key.offset - extent_offset;
                         em->len = num_bytes;
                         em->block_len = num_bytes;
                         em->block_start = disk_bytenr;
+                        em->orig_block_len = disk_num_bytes;
                         em->bdev = root->fs_info->fs_devices->latest_bdev;
                         set_bit(EXTENT_FLAG_PINNED, &em->flags);
+                        set_bit(EXTENT_FLAG_FILLING, &em->flags);
+                        em->generation = -1;
                         while (1) {
                                 write_lock(&em_tree->lock);
                                 ret = add_extent_mapping(em_tree, em);
+                                if (!ret)
+                                        list_move(&em->list,
+                                                  &em_tree->modified_extents);
                                 write_unlock(&em_tree->lock);
                                 if (ret != -EEXIST) {
                                         free_extent_map(em);
@@ -1355,8 +1391,9 @@ out_check:
         }
 
         if (cow_start != (u64)-1) {
-                ret = cow_file_range(inode, locked_page, cow_start, end,
-                                     page_started, nr_written, 1);
+                ret = __cow_file_range(trans, inode, root, locked_page,
+                                       cow_start, end,
+                                       page_started, nr_written, 1);
                 if (ret) {
                         btrfs_abort_transaction(trans, root, ret);
                         goto error;
@@ -1364,11 +1401,7 @@ out_check:
         }
 
 error:
-        if (nolock) {
-                err = btrfs_end_transaction_nolock(trans, root);
-        } else {
-                err = btrfs_end_transaction(trans, root);
-        }
+        err = btrfs_end_transaction(trans, root);
         if (!ret)
                 ret = err;
 
@@ -1538,7 +1571,6 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
                          unsigned long bio_flags)
 {
         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
-        struct btrfs_mapping_tree *map_tree;
         u64 logical = (u64)bio->bi_sector << 9;
         u64 length = 0;
         u64 map_length;
@@ -1548,11 +1580,10 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
                 return 0;
 
         length = bio->bi_size;
-        map_tree = &root->fs_info->mapping_tree;
         map_length = length;
-        ret = btrfs_map_block(map_tree, READ, logical,
+        ret = btrfs_map_block(root->fs_info, READ, logical,
                               &map_length, NULL, 0);
-        /* Will always return 0 or 1 with map_multi == NULL */
+        /* Will always return 0 with map_multi == NULL */
         BUG_ON(ret < 0);
         if (map_length < length + size)
                 return 1;
@@ -1593,7 +1624,12 @@ static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
                           u64 bio_offset)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        return btrfs_map_bio(root, rw, bio, mirror_num, 1);
+        int ret;
+
+        ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
+        if (ret)
+                bio_endio(bio, ret);
+        return ret;
 }
 
 /*
@@ -1608,6 +1644,7 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
         int ret = 0;
         int skip_sum;
         int metadata = 0;
+        int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
 
         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
@@ -1617,31 +1654,43 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
         if (!(rw & REQ_WRITE)) {
                 ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
                 if (ret)
-                        return ret;
+                        goto out;
 
                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
-                        return btrfs_submit_compressed_read(inode, bio,
-                                                    mirror_num, bio_flags);
+                        ret = btrfs_submit_compressed_read(inode, bio,
+                                                           mirror_num,
+                                                           bio_flags);
+                        goto out;
                 } else if (!skip_sum) {
                         ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
                         if (ret)
-                                return ret;
+                                goto out;
                 }
                 goto mapit;
-        } else if (!skip_sum) {
+        } else if (async && !skip_sum) {
                 /* csum items have already been cloned */
                 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
                         goto mapit;
                 /* we're doing a write, do the async checksumming */
-                return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
+                ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
                                    inode, rw, bio, mirror_num,
                                    bio_flags, bio_offset,
                                    __btrfs_submit_bio_start,
                                    __btrfs_submit_bio_done);
+                goto out;
+        } else if (!skip_sum) {
+                ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);
+                if (ret)
+                        goto out;
         }
 
 mapit:
-        return btrfs_map_bio(root, rw, bio, mirror_num, 0);
+        ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
+
+out:
+        if (ret < 0)
+                bio_endio(bio, ret);
+        return ret;
 }
 
 /*
@@ -1664,8 +1713,7 @@ static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
 int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
                               struct extent_state **cached_state)
 {
-        if ((end & (PAGE_CACHE_SIZE - 1)) == 0)
-                WARN_ON(1);
+        WARN_ON((end & (PAGE_CACHE_SIZE - 1)) == 0);
         return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,
                                    cached_state, GFP_NOFS);
 }
@@ -1785,7 +1833,6 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         struct btrfs_path *path;
         struct extent_buffer *leaf;
         struct btrfs_key ins;
-        u64 hint;
         int ret;
 
         path = btrfs_alloc_path();
@@ -1803,8 +1850,8 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
          * the caller is expected to unpin it and allow it to be merged
          * with the others.
          */
-        ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
-                                 &hint, 0);
+        ret = btrfs_drop_extents(trans, root, inode, file_pos,
+                                 file_pos + num_bytes, 0);
         if (ret)
                 goto out;
 
@@ -1828,10 +1875,8 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         btrfs_set_file_extent_encryption(leaf, fi, encryption);
         btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);
 
-        btrfs_unlock_up_safe(path, 1);
-        btrfs_set_lock_blocking(leaf);
-
         btrfs_mark_buffer_dirty(leaf);
+        btrfs_release_path(path);
 
         inode_add_bytes(inode, num_bytes);
 
@@ -1877,22 +1922,20 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
 
         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
                 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
-                ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
-                if (!ret) {
-                        if (nolock)
-                                trans = btrfs_join_transaction_nolock(root);
-                        else
-                                trans = btrfs_join_transaction(root);
-                        if (IS_ERR(trans)) {
-                                ret = PTR_ERR(trans);
-                                trans = NULL;
-                                goto out;
-                        }
-                        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-                        ret = btrfs_update_inode_fallback(trans, root, inode);
-                        if (ret) /* -ENOMEM or corruption */
-                                btrfs_abort_transaction(trans, root, ret);
+                btrfs_ordered_update_i_size(inode, 0, ordered_extent);
+                if (nolock)
+                        trans = btrfs_join_transaction_nolock(root);
+                else
+                        trans = btrfs_join_transaction(root);
+                if (IS_ERR(trans)) {
+                        ret = PTR_ERR(trans);
+                        trans = NULL;
+                        goto out;
                 }
+                trans->block_rsv = &root->fs_info->delalloc_block_rsv;
+                ret = btrfs_update_inode_fallback(trans, root, inode);
+                if (ret) /* -ENOMEM or corruption */
+                        btrfs_abort_transaction(trans, root, ret);
                 goto out;
         }
 
@@ -1929,11 +1972,10 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
                                                 ordered_extent->len,
                                                 compress_type, 0, 0,
                                                 BTRFS_FILE_EXTENT_REG);
-                unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
-                                   ordered_extent->file_offset,
-                                   ordered_extent->len);
         }
-
+        unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
+                           ordered_extent->file_offset, ordered_extent->len,
+                           trans->transid);
         if (ret < 0) {
                 btrfs_abort_transaction(trans, root, ret);
                 goto out_unlock;
@@ -1942,13 +1984,11 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
         add_pending_csums(trans, inode, ordered_extent->file_offset,
                           &ordered_extent->list);
 
-        ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
-        if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
-                ret = btrfs_update_inode_fallback(trans, root, inode);
-                if (ret) { /* -ENOMEM or corruption */
-                        btrfs_abort_transaction(trans, root, ret);
-                        goto out_unlock;
-                }
+        btrfs_ordered_update_i_size(inode, 0, ordered_extent);
+        ret = btrfs_update_inode_fallback(trans, root, inode);
+        if (ret) { /* -ENOMEM or corruption */
+                btrfs_abort_transaction(trans, root, ret);
+                goto out_unlock;
         }
         ret = 0;
 out_unlock:
@@ -1958,12 +1998,8 @@ out_unlock:
 out:
         if (root != root->fs_info->tree_root)
                 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
-        if (trans) {
-                if (nolock)
-                        btrfs_end_transaction_nolock(trans, root);
-                else
-                        btrfs_end_transaction(trans, root);
-        }
+        if (trans)
+                btrfs_end_transaction(trans, root);
 
         if (ret)
                 clear_extent_uptodate(io_tree, ordered_extent->file_offset,
@@ -2119,7 +2155,6 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
         if (empty)
                 return;
 
-        down_read(&root->fs_info->cleanup_work_sem);
         spin_lock(&fs_info->delayed_iput_lock);
         list_splice_init(&fs_info->delayed_iputs, &list);
         spin_unlock(&fs_info->delayed_iput_lock);
@@ -2130,7 +2165,6 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
                 iput(delayed->inode);
                 kfree(delayed);
         }
-        up_read(&root->fs_info->cleanup_work_sem);
 }
 
 enum btrfs_orphan_cleanup_state {
@@ -2198,7 +2232,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
         int ret;
 
         if (!root->orphan_block_rsv) {
-                block_rsv = btrfs_alloc_block_rsv(root);
+                block_rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
                 if (!block_rsv)
                         return -ENOMEM;
         }
@@ -2225,7 +2259,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
                         insert = 1;
 #endif
                 insert = 1;
-                atomic_dec(&root->orphan_inodes);
+                atomic_inc(&root->orphan_inodes);
         }
 
         if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
@@ -2590,6 +2624,18 @@ static void btrfs_read_locked_inode(struct inode *inode)
 
         inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
         BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
+        BTRFS_I(inode)->last_trans = btrfs_inode_transid(leaf, inode_item);
+
+        /*
+         * If we were modified in the current generation and evicted from memory
+         * and then re-read we need to do a full sync since we don't have any
+         * idea about which extents were modified before we were evicted from
+         * cache.
+         */
+        if (BTRFS_I(inode)->last_trans == root->fs_info->generation)
+                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                        &BTRFS_I(inode)->runtime_flags);
+
         inode->i_version = btrfs_inode_sequence(leaf, inode_item);
         inode->i_generation = BTRFS_I(inode)->generation;
         inode->i_rdev = 0;
@@ -2747,8 +2793,9 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
         return btrfs_update_inode_item(trans, root, inode);
 }
 
-static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root, struct inode *inode)
+noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
+                                         struct btrfs_root *root,
+                                         struct inode *inode)
 {
         int ret;
 
@@ -2894,7 +2941,6 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_path *path;
-        struct btrfs_inode_ref *ref;
         struct btrfs_dir_item *di;
         struct inode *inode = dentry->d_inode;
         u64 index;
@@ -3008,17 +3054,17 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         }
         btrfs_release_path(path);
 
-        ref = btrfs_lookup_inode_ref(trans, root, path,
-                                dentry->d_name.name, dentry->d_name.len,
-                                ino, dir_ino, 0);
-        if (IS_ERR(ref)) {
-                err = PTR_ERR(ref);
+        ret = btrfs_get_inode_ref_index(trans, root, path, dentry->d_name.name,
+                                        dentry->d_name.len, ino, dir_ino, 0,
+                                        &index);
+        if (ret) {
+                err = ret;
                 goto out;
         }
-        BUG_ON(!ref); /* Logic error */
+
         if (check_path_shared(root, path))
                 goto out;
-        index = btrfs_inode_ref_index(path->nodes[0], ref);
+
         btrfs_release_path(path);
 
         /*
@@ -3061,7 +3107,7 @@ out:
 static void __unlink_end_trans(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root)
 {
-        if (trans->block_rsv == &root->fs_info->global_block_rsv) {
+        if (trans->block_rsv->type == BTRFS_BLOCK_RSV_GLOBAL) {
                 btrfs_block_rsv_release(root, trans->block_rsv,
                                         trans->bytes_reserved);
                 trans->block_rsv = &root->fs_info->trans_block_rsv;
@@ -3077,7 +3123,6 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
         struct btrfs_trans_handle *trans;
         struct inode *inode = dentry->d_inode;
         int ret;
-        unsigned long nr = 0;
 
         trans = __unlink_start_trans(dir, dentry);
         if (IS_ERR(trans))
@@ -3097,9 +3142,8 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
         }
 
 out:
-        nr = trans->blocks_used;
         __unlink_end_trans(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         return ret;
 }
 
@@ -3189,11 +3233,11 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         int err = 0;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct btrfs_trans_handle *trans;
-        unsigned long nr = 0;
 
-        if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
-            btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
+        if (inode->i_size > BTRFS_EMPTY_DIR_SIZE)
                 return -ENOTEMPTY;
+        if (btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
+                return -EPERM;
 
         trans = __unlink_start_trans(dir, dentry);
         if (IS_ERR(trans))
@@ -3217,9 +3261,8 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         if (!err)
                 btrfs_i_size_write(inode, 0);
 out:
-        nr = trans->blocks_used;
         __unlink_end_trans(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
 
         return err;
 }
@@ -3267,8 +3310,13 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                 return -ENOMEM;
         path->reada = -1;
 
+        /*
+         * We want to drop from the next block forward in case this new size is
+         * not block aligned since we will be keeping the last block of the
+         * extent just the way it is.
+         */
         if (root->ref_cows || root == root->fs_info->tree_root)
-                btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
+                btrfs_drop_extent_cache(inode, (new_size + mask) & (~mask), (u64)-1, 0);
 
         /*
          * This function is also used to drop the items in the log tree before
@@ -3429,12 +3477,6 @@ delete:
 
                 if (path->slots[0] == 0 ||
                     path->slots[0] != pending_del_slot) {
-                        if (root->ref_cows &&
-                            BTRFS_I(inode)->location.objectid !=
-                                                BTRFS_FREE_INO_OBJECTID) {
-                                err = -EAGAIN;
-                                goto out;
-                        }
                         if (pending_del_nr) {
                                 ret = btrfs_del_items(trans, root, path,
                                                 pending_del_slot,
@@ -3465,12 +3507,20 @@ error:
 }
 
 /*
- * taken from block_truncate_page, but does cow as it zeros out
- * any bytes left in the last page in the file.
+ * btrfs_truncate_page - read, zero a chunk and write a page
+ * @inode - inode that we're zeroing
+ * @from - the offset to start zeroing
+ * @len - the length to zero, 0 to zero the entire range respective to the
+ *      offset
+ * @front - zero up to the offset instead of from the offset on
+ *
+ * This will find the page for the "from" offset and cow the page and zero the
+ * part we want to zero.  This is used with truncate and hole punching.
  */
-static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
+int btrfs_truncate_page(struct inode *inode, loff_t from, loff_t len,
+                        int front)
 {
-        struct inode *inode = mapping->host;
+        struct address_space *mapping = inode->i_mapping;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_ordered_extent *ordered;
@@ -3485,17 +3535,18 @@ static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
         u64 page_start;
         u64 page_end;
 
-        if ((offset & (blocksize - 1)) == 0)
+        if ((offset & (blocksize - 1)) == 0 &&
+            (!len || ((len & (blocksize - 1)) == 0)))
                 goto out;
         ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
         if (ret)
                 goto out;
 
-        ret = -ENOMEM;
 again:
         page = find_or_create_page(mapping, index, mask);
         if (!page) {
                 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
+                ret = -ENOMEM;
                 goto out;
         }
 
@@ -3532,7 +3583,8 @@ again:
         }
 
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
-                          EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
+                          EXTENT_DIRTY | EXTENT_DELALLOC |
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
                           0, 0, &cached_state, GFP_NOFS);
 
         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
@@ -3543,10 +3595,14 @@ again:
                 goto out_unlock;
         }
 
-        ret = 0;
         if (offset != PAGE_CACHE_SIZE) {
+                if (!len)
+                        len = PAGE_CACHE_SIZE - offset;
                 kaddr = kmap(page);
-                memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
+                if (front)
+                        memset(kaddr, 0, offset);
+                else
+                        memset(kaddr + offset, 0, len);
                 flush_dcache_page(page);
                 kunmap(page);
         }
@@ -3577,6 +3633,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct extent_map *em = NULL;
         struct extent_state *cached_state = NULL;
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         u64 mask = root->sectorsize - 1;
         u64 hole_start = (oldsize + mask) & ~mask;
         u64 block_end = (size + mask) & ~mask;
@@ -3613,7 +3670,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                 last_byte = min(extent_map_end(em), block_end);
                 last_byte = (last_byte + mask) & ~mask;
                 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
-                        u64 hint_byte = 0;
+                        struct extent_map *hole_em;
                         hole_size = last_byte - cur_offset;
 
                         trans = btrfs_start_transaction(root, 3);
@@ -3622,9 +3679,9 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                                 break;
                         }
 
-                        err = btrfs_drop_extents(trans, inode, cur_offset,
-                                                 cur_offset + hole_size,
-                                                 &hint_byte, 1);
+                        err = btrfs_drop_extents(trans, root, inode,
+                                                 cur_offset,
+                                                 cur_offset + hole_size, 1);
                         if (err) {
                                 btrfs_abort_transaction(trans, root, err);
                                 btrfs_end_transaction(trans, root);
@@ -3641,9 +3698,40 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                                 break;
                         }
 
-                        btrfs_drop_extent_cache(inode, hole_start,
-                                        last_byte - 1, 0);
+                        btrfs_drop_extent_cache(inode, cur_offset,
+                                                cur_offset + hole_size - 1, 0);
+                        hole_em = alloc_extent_map();
+                        if (!hole_em) {
+                                set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                        &BTRFS_I(inode)->runtime_flags);
+                                goto next;
+                        }
+                        hole_em->start = cur_offset;
+                        hole_em->len = hole_size;
+                        hole_em->orig_start = cur_offset;
+
+                        hole_em->block_start = EXTENT_MAP_HOLE;
+                        hole_em->block_len = 0;
+                        hole_em->orig_block_len = 0;
+                        hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
+                        hole_em->compress_type = BTRFS_COMPRESS_NONE;
+                        hole_em->generation = trans->transid;
 
+                        while (1) {
+                                write_lock(&em_tree->lock);
+                                err = add_extent_mapping(em_tree, hole_em);
+                                if (!err)
+                                        list_move(&hole_em->list,
+                                                  &em_tree->modified_extents);
+                                write_unlock(&em_tree->lock);
+                                if (err != -EEXIST)
+                                        break;
+                                btrfs_drop_extent_cache(inode, cur_offset,
+                                                        cur_offset +
+                                                        hole_size - 1, 0);
+                        }
+                        free_extent_map(hole_em);
+next:
                         btrfs_update_inode(trans, root, inode);
                         btrfs_end_transaction(trans, root);
                 }
@@ -3740,7 +3828,6 @@ void btrfs_evict_inode(struct inode *inode)
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_block_rsv *rsv, *global_rsv;
         u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
-        unsigned long nr;
         int ret;
 
         trace_btrfs_inode_evict(inode);
@@ -3768,29 +3855,26 @@ void btrfs_evict_inode(struct inode *inode)
                 goto no_delete;
         }
 
-        rsv = btrfs_alloc_block_rsv(root);
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
         if (!rsv) {
                 btrfs_orphan_del(NULL, inode);
                 goto no_delete;
         }
         rsv->size = min_size;
+        rsv->failfast = 1;
         global_rsv = &root->fs_info->global_block_rsv;
 
         btrfs_i_size_write(inode, 0);
 
         /*
-         * This is a bit simpler than btrfs_truncate since
-         *
-         * 1) We've already reserved our space for our orphan item in the
-         *    unlink.
-         * 2) We're going to delete the inode item, so we don't need to update
-         *    it at all.
-         *
-         * So we just need to reserve some slack space in case we add bytes when
-         * doing the truncate.
+         * This is a bit simpler than btrfs_truncate since we've already
+         * reserved our space for our orphan item in the unlink, so we just
+         * need to reserve some slack space in case we add bytes and update
+         * inode item when doing the truncate.
          */
         while (1) {
-                ret = btrfs_block_rsv_refill_noflush(root, rsv, min_size);
+                ret = btrfs_block_rsv_refill(root, rsv, min_size,
+                                             BTRFS_RESERVE_FLUSH_LIMIT);
 
                 /*
                  * Try and steal from the global reserve since we will
@@ -3808,7 +3892,7 @@ void btrfs_evict_inode(struct inode *inode)
                         goto no_delete;
                 }
 
-                trans = btrfs_start_transaction(root, 0);
+                trans = btrfs_start_transaction_lflush(root, 1);
                 if (IS_ERR(trans)) {
                         btrfs_orphan_del(NULL, inode);
                         btrfs_free_block_rsv(root, rsv);
@@ -3818,13 +3902,16 @@ void btrfs_evict_inode(struct inode *inode)
                 trans->block_rsv = rsv;
 
                 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
-                if (ret != -EAGAIN)
+                if (ret != -ENOSPC)
                         break;
 
-                nr = trans->blocks_used;
+                trans->block_rsv = &root->fs_info->trans_block_rsv;
+                ret = btrfs_update_inode(trans, root, inode);
+                BUG_ON(ret);
+
                 btrfs_end_transaction(trans, root);
                 trans = NULL;
-                btrfs_btree_balance_dirty(root, nr);
+                btrfs_btree_balance_dirty(root);
         }
 
         btrfs_free_block_rsv(root, rsv);
@@ -3840,9 +3927,8 @@ void btrfs_evict_inode(struct inode *inode)
               root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
                 btrfs_return_ino(root, btrfs_ino(inode));
 
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
 no_delete:
         clear_inode(inode);
         return;
@@ -4470,10 +4556,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
                         trans = btrfs_join_transaction(root);
                 if (IS_ERR(trans))
                         return PTR_ERR(trans);
-                if (nolock)
-                        ret = btrfs_end_transaction_nolock(trans, root);
-                else
-                        ret = btrfs_commit_transaction(trans, root);
+                ret = btrfs_commit_transaction(trans, root);
         }
         return ret;
 }
@@ -4671,6 +4754,14 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         BTRFS_I(inode)->generation = trans->transid;
         inode->i_generation = BTRFS_I(inode)->generation;
 
+        /*
+         * We could have gotten an inode number from somebody who was fsynced
+         * and then removed in this same transaction, so let's just set full
+         * sync since it will be a full sync anyway and this will blow away the
+         * old info in the log.
+         */
+        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
+
         if (S_ISDIR(mode))
                 owner = 0;
         else
@@ -4680,6 +4771,12 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
         key[0].offset = 0;
 
+        /*
+         * Start new inodes with an inode_ref. This is slightly more
+         * efficient for small numbers of hard links since they will
+         * be packed into one item. Extended refs will kick in if we
+         * add more hard links than can fit in the ref item.
+         */
         key[1].objectid = objectid;
         btrfs_set_key_type(&key[1], BTRFS_INODE_REF_KEY);
         key[1].offset = ref_objectid;
@@ -4721,8 +4818,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         if (S_ISREG(mode)) {
                 if (btrfs_test_opt(root, NODATASUM))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
-                if (btrfs_test_opt(root, NODATACOW) ||
-                    (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
+                if (btrfs_test_opt(root, NODATACOW))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
         }
 
@@ -4788,7 +4884,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
         ret = btrfs_insert_dir_item(trans, root, name, name_len,
                                     parent_inode, &key,
                                     btrfs_inode_type(inode), index);
-        if (ret == -EEXIST)
+        if (ret == -EEXIST || ret == -EOVERFLOW)
                 goto fail_dir_item;
         else if (ret) {
                 btrfs_abort_transaction(trans, root, ret);
@@ -4843,7 +4939,6 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
         int err;
         int drop_inode = 0;
         u64 objectid;
-        unsigned long nr = 0;
         u64 index = 0;
 
         if (!new_valid_dev(rdev))
@@ -4876,6 +4971,12 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
                 goto out_unlock;
         }
 
+        err = btrfs_update_inode(trans, root, inode);
+        if (err) {
+                drop_inode = 1;
+                goto out_unlock;
+        }
+
         /*
         * If the active LSM wants to access the inode during
         * d_instantiate it needs these. Smack checks to see
@@ -4893,9 +4994,8 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
                 d_instantiate(dentry, inode);
         }
 out_unlock:
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         if (drop_inode) {
                 inode_dec_link_count(inode);
                 iput(inode);
@@ -4909,9 +5009,8 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct inode *inode = NULL;
-        int drop_inode = 0;
+        int drop_inode_on_err = 0;
         int err;
-        unsigned long nr = 0;
         u64 objectid;
         u64 index = 0;
 
@@ -4935,12 +5034,15 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
                 err = PTR_ERR(inode);
                 goto out_unlock;
         }
+        drop_inode_on_err = 1;
 
         err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
-        if (err) {
-                drop_inode = 1;
+        if (err)
+                goto out_unlock;
+
+        err = btrfs_update_inode(trans, root, inode);
+        if (err)
                 goto out_unlock;
-        }
 
         /*
         * If the active LSM wants to access the inode during
@@ -4953,21 +5055,20 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
 
         err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
         if (err)
-                drop_inode = 1;
-        else {
-                inode->i_mapping->a_ops = &btrfs_aops;
-                inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
-                BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
-                d_instantiate(dentry, inode);
-        }
+                goto out_unlock;
+
+        inode->i_mapping->a_ops = &btrfs_aops;
+        inode->i_mapping->backing_dev_info = &root->fs_info->bdi;
+        BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
+        d_instantiate(dentry, inode);
+
 out_unlock:
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
-        if (drop_inode) {
+        if (err && drop_inode_on_err) {
                 inode_dec_link_count(inode);
                 iput(inode);
         }
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         return err;
 }
 
@@ -4978,7 +5079,6 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         struct btrfs_root *root = BTRFS_I(dir)->root;
         struct inode *inode = old_dentry->d_inode;
         u64 index;
-        unsigned long nr = 0;
         int err;
         int drop_inode = 0;
 
@@ -4986,7 +5086,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         if (root->objectid != BTRFS_I(inode)->root->objectid)
                 return -EXDEV;
 
-        if (inode->i_nlink == ~0U)
+        if (inode->i_nlink >= BTRFS_LINK_MAX)
                 return -EMLINK;
 
         err = btrfs_set_inode_index(dir, &index);
@@ -5008,6 +5108,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         inode_inc_iversion(inode);
         inode->i_ctime = CURRENT_TIME;
         ihold(inode);
+        set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
 
         err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
 
@@ -5022,14 +5123,13 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
                 btrfs_log_new_name(trans, inode, NULL, parent);
         }
 
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
 fail:
         if (drop_inode) {
                 inode_dec_link_count(inode);
                 iput(inode);
         }
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         return err;
 }
 
@@ -5042,7 +5142,6 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         int drop_on_err = 0;
         u64 objectid = 0;
         u64 index = 0;
-        unsigned long nr = 1;
 
         /*
          * 2 items for inode and ref
@@ -5088,11 +5187,10 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
         drop_on_err = 0;
 
 out_fail:
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
         if (drop_on_err)
                 iput(inode);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         return err;
 }
 
@@ -5286,6 +5384,7 @@ again:
                 if (start + len <= found_key.offset)
                         goto not_found;
                 em->start = start;
+                em->orig_start = start;
                 em->len = found_key.offset - start;
                 goto not_found_em;
         }
@@ -5296,6 +5395,8 @@ again:
                 em->len = extent_end - extent_start;
                 em->orig_start = extent_start -
                                  btrfs_file_extent_offset(leaf, item);
+                em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf,
+                                                                      item);
                 bytenr = btrfs_file_extent_disk_bytenr(leaf, item);
                 if (bytenr == 0) {
                         em->block_start = EXTENT_MAP_HOLE;
@@ -5305,8 +5406,7 @@ again:
                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                         em->compress_type = compress_type;
                         em->block_start = bytenr;
-                        em->block_len = btrfs_file_extent_disk_num_bytes(leaf,
-                                                                         item);
+                        em->block_len = em->orig_block_len;
                 } else {
                         bytenr += btrfs_file_extent_offset(leaf, item);
                         em->block_start = bytenr;
@@ -5336,7 +5436,8 @@ again:
                 em->start = extent_start + extent_offset;
                 em->len = (copy_size + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
-                em->orig_start = EXTENT_MAP_INLINE;
+                em->orig_block_len = em->len;
+                em->orig_start = em->start;
                 if (compress_type) {
                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                         em->compress_type = compress_type;
@@ -5385,11 +5486,11 @@ again:
                                     extent_map_end(em) - 1, NULL, GFP_NOFS);
                 goto insert;
         } else {
-                printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
-                WARN_ON(1);
+                WARN(1, KERN_ERR "btrfs unknown found_type %d\n", found_type);
         }
 not_found:
         em->start = start;
+        em->orig_start = start;
         em->len = len;
 not_found_em:
         em->block_start = EXTENT_MAP_HOLE;
@@ -5450,7 +5551,8 @@ insert:
         write_unlock(&em_tree->lock);
 out:
 
-        trace_btrfs_get_extent(root, em);
+        if (em)
+                trace_btrfs_get_extent(root, em);
 
         if (path)
                 btrfs_free_path(path);
@@ -5590,38 +5692,19 @@ out:
 }
 
 static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
-                                                  struct extent_map *em,
                                                   u64 start, u64 len)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
-        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct extent_map *em;
         struct btrfs_key ins;
         u64 alloc_hint;
         int ret;
-        bool insert = false;
-
-        /*
-         * Ok if the extent map we looked up is a hole and is for the exact
-         * range we want, there is no reason to allocate a new one, however if
-         * it is not right then we need to free this one and drop the cache for
-         * our range.
-         */
-        if (em->block_start != EXTENT_MAP_HOLE || em->start != start ||
-            em->len != len) {
-                free_extent_map(em);
-                em = NULL;
-                insert = true;
-                btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
-        }
 
         trans = btrfs_join_transaction(root);
         if (IS_ERR(trans))
                 return ERR_CAST(trans);
 
-        if (start <= BTRFS_I(inode)->disk_i_size && len < 64 * 1024)
-                btrfs_add_inode_defrag(trans, inode);
-
         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
         alloc_hint = get_extent_allocation_hint(inode, start, len);
@@ -5632,37 +5715,10 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
                 goto out;
         }
 
-        if (!em) {
-                em = alloc_extent_map();
-                if (!em) {
-                        em = ERR_PTR(-ENOMEM);
-                        goto out;
-                }
-        }
-
-        em->start = start;
-        em->orig_start = em->start;
-        em->len = ins.offset;
-
-        em->block_start = ins.objectid;
-        em->block_len = ins.offset;
-        em->bdev = root->fs_info->fs_devices->latest_bdev;
-
-        /*
-         * We need to do this because if we're using the original em we searched
-         * for, we could have EXTENT_FLAG_VACANCY set, and we don't want that.
-         */
-        em->flags = 0;
-        set_bit(EXTENT_FLAG_PINNED, &em->flags);
-
-        while (insert) {
-                write_lock(&em_tree->lock);
-                ret = add_extent_mapping(em_tree, em);
-                write_unlock(&em_tree->lock);
-                if (ret != -EEXIST)
-                        break;
-                btrfs_drop_extent_cache(inode, start, start + em->len - 1, 0);
-        }
+        em = create_pinned_em(inode, start, ins.offset, start, ins.objectid,
+                              ins.offset, ins.offset, 0);
+        if (IS_ERR(em))
+                goto out;
 
         ret = btrfs_add_ordered_extent_dio(inode, start, ins.objectid,
                                            ins.offset, ins.offset, 0);
@@ -5836,6 +5892,53 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,
         return ret;
 }
 
+static struct extent_map *create_pinned_em(struct inode *inode, u64 start,
+                                           u64 len, u64 orig_start,
+                                           u64 block_start, u64 block_len,
+                                           u64 orig_block_len, int type)
+{
+        struct extent_map_tree *em_tree;
+        struct extent_map *em;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        em_tree = &BTRFS_I(inode)->extent_tree;
+        em = alloc_extent_map();
+        if (!em)
+                return ERR_PTR(-ENOMEM);
+
+        em->start = start;
+        em->orig_start = orig_start;
+        em->len = len;
+        em->block_len = block_len;
+        em->block_start = block_start;
+        em->bdev = root->fs_info->fs_devices->latest_bdev;
+        em->orig_block_len = orig_block_len;
+        em->generation = -1;
+        set_bit(EXTENT_FLAG_PINNED, &em->flags);
+        if (type == BTRFS_ORDERED_PREALLOC)
+                set_bit(EXTENT_FLAG_FILLING, &em->flags);
+
+        do {
+                btrfs_drop_extent_cache(inode, em->start,
+                                em->start + em->len - 1, 0);
+                write_lock(&em_tree->lock);
+                ret = add_extent_mapping(em_tree, em);
+                if (!ret)
+                        list_move(&em->list,
+                                  &em_tree->modified_extents);
+                write_unlock(&em_tree->lock);
+        } while (ret == -EEXIST);
+
+        if (ret) {
+                free_extent_map(em);
+                return ERR_PTR(ret);
+        }
+
+        return em;
+}
+
+
 static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                                    struct buffer_head *bh_result, int create)
 {
@@ -5950,6 +6053,21 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                         goto must_cow;
 
                 if (can_nocow_odirect(trans, inode, start, len) == 1) {
+                        u64 orig_start = em->orig_start;
+                        u64 orig_block_len = em->orig_block_len;
+
+                        if (type == BTRFS_ORDERED_PREALLOC) {
+                                free_extent_map(em);
+                                em = create_pinned_em(inode, start, len,
+                                                       orig_start,
+                                                       block_start, len,
+                                                       orig_block_len, type);
+                                if (IS_ERR(em)) {
+                                        btrfs_end_transaction(trans, root);
+                                        goto unlock_err;
+                                }
+                        }
+
                         ret = btrfs_add_ordered_extent_dio(inode, start,
                                            block_start, len, len, type);
                         btrfs_end_transaction(trans, root);
@@ -5967,7 +6085,8 @@ must_cow:
          * it above
          */
         len = bh_result->b_size;
-        em = btrfs_new_extent_direct(inode, em, start, len);
+        free_extent_map(em);
+        em = btrfs_new_extent_direct(inode, start, len);
         if (IS_ERR(em)) {
                 ret = PTR_ERR(em);
                 goto unlock_err;
@@ -5999,7 +6118,8 @@ unlock:
         if (lockstart < lockend) {
                 if (create && len < lockend - lockstart) {
                         clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
-                                         lockstart + len - 1, unlock_bits, 1, 0,
+                                         lockstart + len - 1,
+                                         unlock_bits | EXTENT_DEFRAG, 1, 0,
                                          &cached_state, GFP_NOFS);
                         /*
                          * Beside unlock, we also need to cleanup reserved space
@@ -6007,8 +6127,8 @@ unlock:
                          */
                         clear_extent_bit(&BTRFS_I(inode)->io_tree,
                                          lockstart + len, lockend,
-                                         unlock_bits | EXTENT_DO_ACCOUNTING,
-                                         1, 0, NULL, GFP_NOFS);
+                                         unlock_bits | EXTENT_DO_ACCOUNTING |
+                                         EXTENT_DEFRAG, 1, 0, NULL, GFP_NOFS);
                 } else {
                         clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
                                          lockend, unlock_bits, 1, 0,
@@ -6207,6 +6327,9 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
 
+        if (async_submit)
+                async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
+
         bio_get(bio);
 
         if (!write) {
@@ -6251,7 +6374,6 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
 {
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
         struct bio *bio;
         struct bio *orig_bio = dip->orig_bio;
         struct bio_vec *bvec = orig_bio->bi_io_vec;
@@ -6264,7 +6386,7 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
         int async_submit = 0;
 
         map_length = orig_bio->bi_size;
-        ret = btrfs_map_block(map_tree, READ, start_sector << 9,
+        ret = btrfs_map_block(root->fs_info, READ, start_sector << 9,
                               &map_length, NULL, 0);
         if (ret) {
                 bio_put(orig_bio);
@@ -6318,7 +6440,8 @@ static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
                         bio->bi_end_io = btrfs_end_dio_bio;
 
                         map_length = orig_bio->bi_size;
-                        ret = btrfs_map_block(map_tree, READ, start_sector << 9,
+                        ret = btrfs_map_block(root->fs_info, READ,
+                                              start_sector << 9,
                                               &map_length, NULL, 0);
                         if (ret) {
                                 bio_put(bio);
@@ -6471,9 +6594,17 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
                    btrfs_submit_direct, 0);
 }
 
+#define BTRFS_FIEMAP_FLAGS      (FIEMAP_FLAG_SYNC)
+
 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                 __u64 start, __u64 len)
 {
+        int     ret;
+
+        ret = fiemap_check_flags(fieinfo, BTRFS_FIEMAP_FLAGS);
+        if (ret)
+                return ret;
+
         return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
 }
 
@@ -6573,8 +6704,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
                  */
                 clear_extent_bit(tree, page_start, page_end,
                                  EXTENT_DIRTY | EXTENT_DELALLOC |
-                                 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING, 1, 0,
-                                 &cached_state, GFP_NOFS);
+                                 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
+                                 EXTENT_DEFRAG, 1, 0, &cached_state, GFP_NOFS);
                 /*
                  * whoever cleared the private bit is responsible
                  * for the finish_ordered_io
@@ -6590,7 +6721,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
         }
         clear_extent_bit(tree, page_start, page_end,
                  EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
-                 EXTENT_DO_ACCOUNTING, 1, 1, &cached_state, GFP_NOFS);
+                 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 1, 1,
+                 &cached_state, GFP_NOFS);
         __btrfs_releasepage(page, GFP_NOFS);
 
         ClearPageChecked(page);
@@ -6687,7 +6819,8 @@ again:
          * prepare_pages in the normal write path.
          */
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, page_end,
-                          EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
+                          EXTENT_DIRTY | EXTENT_DELALLOC |
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
                           0, 0, &cached_state, GFP_NOFS);
 
         ret = btrfs_set_extent_delalloc(inode, page_start, page_end,
@@ -6718,6 +6851,7 @@ again:
 
         BTRFS_I(inode)->last_trans = root->fs_info->generation;
         BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
 
         unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
 
@@ -6741,11 +6875,10 @@ static int btrfs_truncate(struct inode *inode)
         int ret;
         int err = 0;
         struct btrfs_trans_handle *trans;
-        unsigned long nr;
         u64 mask = root->sectorsize - 1;
         u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
 
-        ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
+        ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
         if (ret)
                 return ret;
 
@@ -6788,10 +6921,11 @@ static int btrfs_truncate(struct inode *inode)
          * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
          * updating the inode.
          */
-        rsv = btrfs_alloc_block_rsv(root);
+        rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
         if (!rsv)
                 return -ENOMEM;
         rsv->size = min_size;
+        rsv->failfast = 1;
 
         /*
          * 1 for the truncate slack space
@@ -6837,36 +6971,21 @@ static int btrfs_truncate(struct inode *inode)
                                            &BTRFS_I(inode)->runtime_flags))
                 btrfs_add_ordered_operation(trans, root, inode);
 
-        while (1) {
-                ret = btrfs_block_rsv_refill(root, rsv, min_size);
-                if (ret) {
-                        /*
-                         * This can only happen with the original transaction we
-                         * started above, every other time we shouldn't have a
-                         * transaction started yet.
-                         */
-                        if (ret == -EAGAIN)
-                                goto end_trans;
-                        err = ret;
-                        break;
-                }
-
-                if (!trans) {
-                        /* Just need the 1 for updating the inode */
-                        trans = btrfs_start_transaction(root, 1);
-                        if (IS_ERR(trans)) {
-                                ret = err = PTR_ERR(trans);
-                                trans = NULL;
-                                break;
-                        }
-                }
-
-                trans->block_rsv = rsv;
+        /*
+         * So if we truncate and then write and fsync we normally would just
+         * write the extents that changed, which is a problem if we need to
+         * first truncate that entire inode.  So set this flag so we write out
+         * all of the extents in the inode to the sync log so we're completely
+         * safe.
+         */
+        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &BTRFS_I(inode)->runtime_flags);
+        trans->block_rsv = rsv;
 
+        while (1) {
                 ret = btrfs_truncate_inode_items(trans, root, inode,
                                                  inode->i_size,
                                                  BTRFS_EXTENT_DATA_KEY);
-                if (ret != -EAGAIN) {
+                if (ret != -ENOSPC) {
                         err = ret;
                         break;
                 }
@@ -6877,11 +6996,21 @@ static int btrfs_truncate(struct inode *inode)
                         err = ret;
                         break;
                 }
-end_trans:
-                nr = trans->blocks_used;
+
                 btrfs_end_transaction(trans, root);
-                trans = NULL;
-                btrfs_btree_balance_dirty(root, nr);
+                btrfs_btree_balance_dirty(root);
+
+                trans = btrfs_start_transaction(root, 2);
+                if (IS_ERR(trans)) {
+                        ret = err = PTR_ERR(trans);
+                        trans = NULL;
+                        break;
+                }
+
+                ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
+                                              rsv, min_size);
+                BUG_ON(ret);    /* shouldn't happen */
+                trans->block_rsv = rsv;
         }
 
         if (ret == 0 && inode->i_nlink > 0) {
@@ -6903,9 +7032,8 @@ end_trans:
                 if (ret && !err)
                         err = ret;
 
-                nr = trans->blocks_used;
                 ret = btrfs_end_transaction(trans, root);
-                btrfs_btree_balance_dirty(root, nr);
+                btrfs_btree_balance_dirty(root);
         }
 
 out:
@@ -6965,6 +7093,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->csum_bytes = 0;
         ei->index_cnt = (u64)-1;
         ei->last_unlink_trans = 0;
+        ei->last_log_commit = 0;
 
         spin_lock_init(&ei->lock);
         ei->outstanding_extents = 0;
@@ -6981,6 +7110,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
         ei->io_tree.track_uptodate = 1;
         ei->io_failure_tree.track_uptodate = 1;
+        atomic_set(&ei->sync_writers, 0);
         mutex_init(&ei->log_mutex);
         mutex_init(&ei->delalloc_mutex);
         btrfs_ordered_inode_tree_init(&ei->ordered_tree);
@@ -7091,40 +7221,49 @@ void btrfs_destroy_cachep(void)
                 kmem_cache_destroy(btrfs_path_cachep);
         if (btrfs_free_space_cachep)
                 kmem_cache_destroy(btrfs_free_space_cachep);
+        if (btrfs_delalloc_work_cachep)
+                kmem_cache_destroy(btrfs_delalloc_work_cachep);
 }
 
 int btrfs_init_cachep(void)
 {
-        btrfs_inode_cachep = kmem_cache_create("btrfs_inode_cache",
+        btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
                         sizeof(struct btrfs_inode), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once);
         if (!btrfs_inode_cachep)
                 goto fail;
 
-        btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle_cache",
+        btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle",
                         sizeof(struct btrfs_trans_handle), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_trans_handle_cachep)
                 goto fail;
 
-        btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction_cache",
+        btrfs_transaction_cachep = kmem_cache_create("btrfs_transaction",
                         sizeof(struct btrfs_transaction), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_transaction_cachep)
                 goto fail;
 
-        btrfs_path_cachep = kmem_cache_create("btrfs_path_cache",
+        btrfs_path_cachep = kmem_cache_create("btrfs_path",
                         sizeof(struct btrfs_path), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_path_cachep)
                 goto fail;
 
-        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
+        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space",
                         sizeof(struct btrfs_free_space), 0,
                         SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
         if (!btrfs_free_space_cachep)
                 goto fail;
 
+        btrfs_delalloc_work_cachep = kmem_cache_create("btrfs_delalloc_work",
+                        sizeof(struct btrfs_delalloc_work), 0,
+                        SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                        NULL);
+        if (!btrfs_delalloc_work_cachep)
+                goto fail;
+
         return 0;
 fail:
         btrfs_destroy_cachep();
@@ -7196,6 +7335,28 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (S_ISDIR(old_inode->i_mode) && new_inode &&
             new_inode->i_size > BTRFS_EMPTY_DIR_SIZE)
                 return -ENOTEMPTY;
+
+
+        /* check for collisions, even if the  name isn't there */
+        ret = btrfs_check_dir_item_collision(root, new_dir->i_ino,
+                             new_dentry->d_name.name,
+                             new_dentry->d_name.len);
+
+        if (ret) {
+                if (ret == -EEXIST) {
+                        /* we shouldn't get
+                         * eexist without a new_inode */
+                        if (!new_inode) {
+                                WARN_ON(1);
+                                return ret;
+                        }
+                } else {
+                        /* maybe -EOVERFLOW */
+                        return ret;
+                }
+        }
+        ret = 0;
+
         /*
          * we're using rename to replace one file with another.
          * and the replacement file is large.  Start IO on it now so
@@ -7335,6 +7496,49 @@ out_notrans:
         return ret;
 }
 
+static void btrfs_run_delalloc_work(struct btrfs_work *work)
+{
+        struct btrfs_delalloc_work *delalloc_work;
+
+        delalloc_work = container_of(work, struct btrfs_delalloc_work,
+                                     work);
+        if (delalloc_work->wait)
+                btrfs_wait_ordered_range(delalloc_work->inode, 0, (u64)-1);
+        else
+                filemap_flush(delalloc_work->inode->i_mapping);
+
+        if (delalloc_work->delay_iput)
+                btrfs_add_delayed_iput(delalloc_work->inode);
+        else
+                iput(delalloc_work->inode);
+        complete(&delalloc_work->completion);
+}
+
+struct btrfs_delalloc_work *btrfs_alloc_delalloc_work(struct inode *inode,
+                                                    int wait, int delay_iput)
+{
+        struct btrfs_delalloc_work *work;
+
+        work = kmem_cache_zalloc(btrfs_delalloc_work_cachep, GFP_NOFS);
+        if (!work)
+                return NULL;
+
+        init_completion(&work->completion);
+        INIT_LIST_HEAD(&work->list);
+        work->inode = inode;
+        work->wait = wait;
+        work->delay_iput = delay_iput;
+        work->work.func = btrfs_run_delalloc_work;
+
+        return work;
+}
+
+void btrfs_wait_and_free_delalloc_work(struct btrfs_delalloc_work *work)
+{
+        wait_for_completion(&work->completion);
+        kmem_cache_free(btrfs_delalloc_work_cachep, work);
+}
+
 /*
  * some fairly slow code that needs optimization. This walks the list
  * of all the inodes with pending delalloc and forces them to disk.
@@ -7344,10 +7548,15 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
         struct list_head *head = &root->fs_info->delalloc_inodes;
         struct btrfs_inode *binode;
         struct inode *inode;
+        struct btrfs_delalloc_work *work, *next;
+        struct list_head works;
+        int ret = 0;
 
         if (root->fs_info->sb->s_flags & MS_RDONLY)
                 return -EROFS;
 
+        INIT_LIST_HEAD(&works);
+
         spin_lock(&root->fs_info->delalloc_lock);
         while (!list_empty(head)) {
                 binode = list_entry(head->next, struct btrfs_inode,
@@ -7357,11 +7566,14 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
                         list_del_init(&binode->delalloc_inodes);
                 spin_unlock(&root->fs_info->delalloc_lock);
                 if (inode) {
-                        filemap_flush(inode->i_mapping);
-                        if (delay_iput)
-                                btrfs_add_delayed_iput(inode);
-                        else
-                                iput(inode);
+                        work = btrfs_alloc_delalloc_work(inode, 0, delay_iput);
+                        if (!work) {
+                                ret = -ENOMEM;
+                                goto out;
+                        }
+                        list_add_tail(&work->list, &works);
+                        btrfs_queue_worker(&root->fs_info->flush_workers,
+                                           &work->work);
                 }
                 cond_resched();
                 spin_lock(&root->fs_info->delalloc_lock);
@@ -7380,7 +7592,12 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
                     atomic_read(&root->fs_info->async_delalloc_pages) == 0));
         }
         atomic_dec(&root->fs_info->async_submit_draining);
-        return 0;
+out:
+        list_for_each_entry_safe(work, next, &works, list) {
+                list_del_init(&work->list);
+                btrfs_wait_and_free_delalloc_work(work);
+        }
+        return ret;
 }
 
 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
@@ -7400,7 +7617,6 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
         unsigned long ptr;
         struct btrfs_file_extent_item *ei;
         struct extent_buffer *leaf;
-        unsigned long nr = 0;
 
         name_len = strlen(symname) + 1;
         if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
@@ -7498,13 +7714,12 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
 out_unlock:
         if (!err)
                 d_instantiate(dentry, inode);
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
         if (drop_inode) {
                 inode_dec_link_count(inode);
                 iput(inode);
         }
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         return err;
 }
 
@@ -7513,6 +7728,8 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                        loff_t actual_len, u64 *alloc_hint,
                                        struct btrfs_trans_handle *trans)
 {
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct extent_map *em;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_key ins;
         u64 cur_offset = start;
@@ -7553,6 +7770,38 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                 btrfs_drop_extent_cache(inode, cur_offset,
                                         cur_offset + ins.offset -1, 0);
 
+                em = alloc_extent_map();
+                if (!em) {
+                        set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                &BTRFS_I(inode)->runtime_flags);
+                        goto next;
+                }
+
+                em->start = cur_offset;
+                em->orig_start = cur_offset;
+                em->len = ins.offset;
+                em->block_start = ins.objectid;
+                em->block_len = ins.offset;
+                em->orig_block_len = ins.offset;
+                em->bdev = root->fs_info->fs_devices->latest_bdev;
+                set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
+                em->generation = trans->transid;
+
+                while (1) {
+                        write_lock(&em_tree->lock);
+                        ret = add_extent_mapping(em_tree, em);
+                        if (!ret)
+                                list_move(&em->list,
+                                          &em_tree->modified_extents);
+                        write_unlock(&em_tree->lock);
+                        if (ret != -EEXIST)
+                                break;
+                        btrfs_drop_extent_cache(inode, cur_offset,
+                                                cur_offset + ins.offset - 1,
+                                                0);
+                }
+                free_extent_map(em);
+next:
                 num_bytes -= ins.offset;
                 cur_offset += ins.offset;
                 *alloc_hint = ins.objectid + ins.offset;
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 47127c1bd290..4b4516770f05 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -55,6 +55,7 @@
 #include "backref.h"
 #include "rcu-string.h"
 #include "send.h"
+#include "dev-replace.h"
 
 /* Mask out flags that are inappropriate for the given type of inode. */
 static inline __u32 btrfs_mask_flags(umode_t mode, __u32 flags)
@@ -140,8 +141,11 @@ void btrfs_inherit_iflags(struct inode *inode, struct inode *dir)
                 BTRFS_I(inode)->flags |= BTRFS_INODE_COMPRESS;
         }
 
-        if (flags & BTRFS_INODE_NODATACOW)
+        if (flags & BTRFS_INODE_NODATACOW) {
                 BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
+                if (S_ISREG(inode->i_mode))
+                        BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
+        }
 
         btrfs_update_iflags(inode);
 }
@@ -181,6 +185,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         int ret;
         u64 ip_oldflags;
         unsigned int i_oldflags;
+        umode_t mode;
 
         if (btrfs_root_readonly(root))
                 return -EROFS;
@@ -203,6 +208,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
 
         ip_oldflags = ip->flags;
         i_oldflags = inode->i_flags;
+        mode = inode->i_mode;
 
         flags = btrfs_mask_flags(inode->i_mode, flags);
         oldflags = btrfs_flags_to_ioctl(ip->flags);
@@ -237,10 +243,31 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
                 ip->flags |= BTRFS_INODE_DIRSYNC;
         else
                 ip->flags &= ~BTRFS_INODE_DIRSYNC;
-        if (flags & FS_NOCOW_FL)
-                ip->flags |= BTRFS_INODE_NODATACOW;
-        else
-                ip->flags &= ~BTRFS_INODE_NODATACOW;
+        if (flags & FS_NOCOW_FL) {
+                if (S_ISREG(mode)) {
+                        /*
+                         * It's safe to turn csums off here, no extents exist.
+                         * Otherwise we want the flag to reflect the real COW
+                         * status of the file and will not set it.
+                         */
+                        if (inode->i_size == 0)
+                                ip->flags |= BTRFS_INODE_NODATACOW
+                                           | BTRFS_INODE_NODATASUM;
+                } else {
+                        ip->flags |= BTRFS_INODE_NODATACOW;
+                }
+        } else {
+                /*
+                 * Revert back under same assuptions as above
+                 */
+                if (S_ISREG(mode)) {
+                        if (inode->i_size == 0)
+                                ip->flags &= ~(BTRFS_INODE_NODATACOW
+                                             | BTRFS_INODE_NODATASUM);
+                } else {
+                        ip->flags &= ~BTRFS_INODE_NODATACOW;
+                }
+        }
 
         /*
          * The COMPRESS flag can only be changed by users, while the NOCOMPRESS
@@ -320,7 +347,8 @@ static noinline int btrfs_ioctl_fitrim(struct file *file, void __user *arg)
                 return -EOPNOTSUPP;
         if (copy_from_user(&range, arg, sizeof(range)))
                 return -EFAULT;
-        if (range.start > total_bytes)
+        if (range.start > total_bytes ||
+            range.len < fs_info->sb->s_blocksize)
                 return -EINVAL;
 
         range.len = min(range.len, total_bytes - range.start);
@@ -516,7 +544,8 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
         if (!pending_snapshot)
                 return -ENOMEM;
 
-        btrfs_init_block_rsv(&pending_snapshot->block_rsv);
+        btrfs_init_block_rsv(&pending_snapshot->block_rsv,
+                             BTRFS_BLOCK_RSV_TEMP);
         pending_snapshot->dentry = dentry;
         pending_snapshot->root = root;
         pending_snapshot->readonly = readonly;
@@ -525,7 +554,7 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
                 *inherit = NULL;        /* take responsibility to free it */
         }
 
-        trans = btrfs_start_transaction(root->fs_info->extent_root, 5);
+        trans = btrfs_start_transaction(root->fs_info->extent_root, 6);
         if (IS_ERR(trans)) {
                 ret = PTR_ERR(trans);
                 goto fail;
@@ -546,7 +575,12 @@ static int create_snapshot(struct btrfs_root *root, struct dentry *dentry,
                 ret = btrfs_commit_transaction(trans,
                                                root->fs_info->extent_root);
         }
-        BUG_ON(ret);
+        if (ret) {
+                /* cleanup_transaction has freed this for us */
+                if (trans->aborted)
+                        pending_snapshot = NULL;
+                goto fail;
+        }
 
         ret = pending_snapshot->error;
         if (ret)
@@ -614,7 +648,7 @@ static int btrfs_may_delete(struct inode *dir,struct dentry *victim,int isdir)
                 return -ENOENT;
 
         BUG_ON(victim->d_parent->d_inode != dir);
-        audit_inode_child(victim, dir);
+        audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
 
         error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
         if (error)
@@ -679,6 +713,16 @@ static noinline int btrfs_mksubvol(struct path *parent,
         if (error)
                 goto out_dput;
 
+        /*
+         * even if this name doesn't exist, we may get hash collisions.
+         * check for them now when we can safely fail
+         */
+        error = btrfs_check_dir_item_collision(BTRFS_I(dir)->root,
+                                               dir->i_ino, name,
+                                               namelen);
+        if (error)
+                goto out_dput;
+
         down_read(&BTRFS_I(dir)->root->fs_info->subvol_sem);
 
         if (btrfs_root_refs(&BTRFS_I(dir)->root->root_item) == 0)
@@ -1022,8 +1066,8 @@ again:
                          page_start, page_end - 1, 0, &cached_state);
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
                           page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
-                          EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
-                          GFP_NOFS);
+                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
+                          &cached_state, GFP_NOFS);
 
         if (i_done != page_cnt) {
                 spin_lock(&BTRFS_I(inode)->lock);
@@ -1034,8 +1078,8 @@ again:
         }
 
 
-        btrfs_set_extent_delalloc(inode, page_start, page_end - 1,
-                                  &cached_state);
+        set_extent_defrag(&BTRFS_I(inode)->io_tree, page_start, page_end - 1,
+                          &cached_state, GFP_NOFS);
 
         unlock_extent_cached(&BTRFS_I(inode)->io_tree,
                              page_start, page_end - 1, &cached_state,
@@ -1199,7 +1243,7 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                 }
 
                 defrag_count += ret;
-                balance_dirty_pages_ratelimited_nr(inode->i_mapping, ret);
+                balance_dirty_pages_ratelimited(inode->i_mapping);
                 mutex_unlock(&inode->i_mutex);
 
                 if (newer_than) {
@@ -1267,12 +1311,13 @@ out_ra:
         return ret;
 }
 
-static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
+static noinline int btrfs_ioctl_resize(struct file *file,
                                         void __user *arg)
 {
         u64 new_size;
         u64 old_size;
         u64 devid = 1;
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_vol_args *vol_args;
         struct btrfs_trans_handle *trans;
         struct btrfs_device *device = NULL;
@@ -1287,13 +1332,17 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        mutex_lock(&root->fs_info->volume_mutex);
-        if (root->fs_info->balance_ctl) {
-                printk(KERN_INFO "btrfs: balance in progress\n");
-                ret = -EINVAL;
-                goto out;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
+
+        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
+                return -EINPROGRESS;
         }
 
+        mutex_lock(&root->fs_info->volume_mutex);
         vol_args = memdup_user(arg, sizeof(*vol_args));
         if (IS_ERR(vol_args)) {
                 ret = PTR_ERR(vol_args);
@@ -1313,7 +1362,7 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
                 printk(KERN_INFO "btrfs: resizing devid %llu\n",
                        (unsigned long long)devid);
         }
-        device = btrfs_find_device(root, devid, NULL, NULL);
+        device = btrfs_find_device(root->fs_info, devid, NULL, NULL);
         if (!device) {
                 printk(KERN_INFO "btrfs: resizer unable to find device %llu\n",
                        (unsigned long long)devid);
@@ -1345,6 +1394,11 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
                 }
         }
 
+        if (device->is_tgtdev_for_dev_replace) {
+                ret = -EINVAL;
+                goto out_free;
+        }
+
         old_size = device->total_bytes;
 
         if (mod < 0) {
@@ -1383,12 +1437,14 @@ static noinline int btrfs_ioctl_resize(struct btrfs_root *root,
                 btrfs_commit_transaction(trans, root);
         } else if (new_size < old_size) {
                 ret = btrfs_shrink_device(device, new_size);
-        }
+        } /* equal, nothing need to do */
 
 out_free:
         kfree(vol_args);
 out:
         mutex_unlock(&root->fs_info->volume_mutex);
+        mnt_drop_write_file(file);
+        atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
         return ret;
 }
 
@@ -2130,9 +2186,17 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
         if (btrfs_root_readonly(root))
                 return -EROFS;
 
+        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
+                return -EINPROGRESS;
+        }
         ret = mnt_want_write_file(file);
-        if (ret)
+        if (ret) {
+                atomic_set(&root->fs_info->mutually_exclusive_operation_running,
+                           0);
                 return ret;
+        }
 
         switch (inode->i_mode & S_IFMT) {
         case S_IFDIR:
@@ -2184,6 +2248,7 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
         }
 out:
         mnt_drop_write_file(file);
+        atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
         return ret;
 }
 
@@ -2195,13 +2260,13 @@ static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        mutex_lock(&root->fs_info->volume_mutex);
-        if (root->fs_info->balance_ctl) {
-                printk(KERN_INFO "btrfs: balance in progress\n");
-                ret = -EINVAL;
-                goto out;
+        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
+                return -EINPROGRESS;
         }
 
+        mutex_lock(&root->fs_info->volume_mutex);
         vol_args = memdup_user(arg, sizeof(*vol_args));
         if (IS_ERR(vol_args)) {
                 ret = PTR_ERR(vol_args);
@@ -2214,27 +2279,31 @@ static long btrfs_ioctl_add_dev(struct btrfs_root *root, void __user *arg)
         kfree(vol_args);
 out:
         mutex_unlock(&root->fs_info->volume_mutex);
+        atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
         return ret;
 }
 
-static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_rm_dev(struct file *file, void __user *arg)
 {
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_vol_args *vol_args;
         int ret;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
 
-        mutex_lock(&root->fs_info->volume_mutex);
-        if (root->fs_info->balance_ctl) {
-                printk(KERN_INFO "btrfs: balance in progress\n");
-                ret = -EINVAL;
-                goto out;
+        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
+                mnt_drop_write_file(file);
+                return -EINPROGRESS;
         }
 
+        mutex_lock(&root->fs_info->volume_mutex);
         vol_args = memdup_user(arg, sizeof(*vol_args));
         if (IS_ERR(vol_args)) {
                 ret = PTR_ERR(vol_args);
@@ -2247,6 +2316,8 @@ static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
         kfree(vol_args);
 out:
         mutex_unlock(&root->fs_info->volume_mutex);
+        mnt_drop_write_file(file);
+        atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
         return ret;
 }
 
@@ -2302,7 +2373,7 @@ static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
                 s_uuid = di_args->uuid;
 
         mutex_lock(&fs_devices->device_list_mutex);
-        dev = btrfs_find_device(root, di_args->devid, s_uuid, NULL);
+        dev = btrfs_find_device(root->fs_info, di_args->devid, s_uuid, NULL);
         mutex_unlock(&fs_devices->device_list_mutex);
 
         if (!dev) {
@@ -2351,7 +2422,6 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         int ret;
         u64 len = olen;
         u64 bs = root->fs_info->sb->s_blocksize;
-        u64 hint_byte;
 
         /*
          * TODO:
@@ -2456,13 +2526,13 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
            another, and lock file content */
         while (1) {
                 struct btrfs_ordered_extent *ordered;
-                lock_extent(&BTRFS_I(src)->io_tree, off, off+len);
-                ordered = btrfs_lookup_first_ordered_extent(src, off+len);
+                lock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
+                ordered = btrfs_lookup_first_ordered_extent(src, off + len - 1);
                 if (!ordered &&
-                    !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len,
-                                   EXTENT_DELALLOC, 0, NULL))
+                    !test_range_bit(&BTRFS_I(src)->io_tree, off, off + len - 1,
+                                    EXTENT_DELALLOC, 0, NULL))
                         break;
-                unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
+                unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
                 if (ordered)
                         btrfs_put_ordered_extent(ordered);
                 btrfs_wait_ordered_range(src, off, len);
@@ -2536,7 +2606,7 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         btrfs_release_path(path);
 
                         if (key.offset + datal <= off ||
-                            key.offset >= off+len)
+                            key.offset >= off + len - 1)
                                 goto next;
 
                         memcpy(&new_key, &key, sizeof(new_key));
@@ -2574,10 +2644,10 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                         datal -= off - key.offset;
                                 }
 
-                                ret = btrfs_drop_extents(trans, inode,
+                                ret = btrfs_drop_extents(trans, root, inode,
                                                          new_key.offset,
                                                          new_key.offset + datal,
-                                                         &hint_byte, 1);
+                                                         1);
                                 if (ret) {
                                         btrfs_abort_transaction(trans, root,
                                                                 ret);
@@ -2637,8 +2707,8 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                         new_key.offset += skip;
                                 }
 
-                                if (key.offset + datal > off+len)
-                                        trim = key.offset + datal - (off+len);
+                                if (key.offset + datal > off + len)
+                                        trim = key.offset + datal - (off + len);
 
                                 if (comp && (skip || trim)) {
                                         ret = -EINVAL;
@@ -2648,10 +2718,10 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                 size -= skip + trim;
                                 datal -= skip + trim;
 
-                                ret = btrfs_drop_extents(trans, inode,
+                                ret = btrfs_drop_extents(trans, root, inode,
                                                          new_key.offset,
                                                          new_key.offset + datal,
-                                                         &hint_byte, 1);
+                                                         1);
                                 if (ret) {
                                         btrfs_abort_transaction(trans, root,
                                                                 ret);
@@ -2715,7 +2785,7 @@ next:
         ret = 0;
 out:
         btrfs_release_path(path);
-        unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
+        unlock_extent(&BTRFS_I(src)->io_tree, off, off + len - 1);
 out_unlock:
         mutex_unlock(&src->i_mutex);
         mutex_unlock(&inode->i_mutex);
@@ -2796,12 +2866,19 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
         struct btrfs_disk_key disk_key;
         u64 objectid = 0;
         u64 dir_id;
+        int ret;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (copy_from_user(&objectid, argp, sizeof(objectid)))
-                return -EFAULT;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
+
+        if (copy_from_user(&objectid, argp, sizeof(objectid))) {
+                ret = -EFAULT;
+                goto out;
+        }
 
         if (!objectid)
                 objectid = root->root_key.objectid;
@@ -2811,21 +2888,28 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
         location.offset = (u64)-1;
 
         new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
-        if (IS_ERR(new_root))
-                return PTR_ERR(new_root);
+        if (IS_ERR(new_root)) {
+                ret = PTR_ERR(new_root);
+                goto out;
+        }
 
-        if (btrfs_root_refs(&new_root->root_item) == 0)
-                return -ENOENT;
+        if (btrfs_root_refs(&new_root->root_item) == 0) {
+                ret = -ENOENT;
+                goto out;
+        }
 
         path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
         path->leave_spinning = 1;
 
         trans = btrfs_start_transaction(root, 1);
         if (IS_ERR(trans)) {
                 btrfs_free_path(path);
-                return PTR_ERR(trans);
+                ret = PTR_ERR(trans);
+                goto out;
         }
 
         dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
@@ -2836,7 +2920,8 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
                 btrfs_end_transaction(trans, root);
                 printk(KERN_ERR "Umm, you don't have the default dir item, "
                        "this isn't going to work\n");
-                return -ENOENT;
+                ret = -ENOENT;
+                goto out;
         }
 
         btrfs_cpu_key_to_disk(&disk_key, &new_root->root_key);
@@ -2846,12 +2931,13 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
 
         btrfs_set_fs_incompat(root->fs_info, DEFAULT_SUBVOL);
         btrfs_end_transaction(trans, root);
-
-        return 0;
+out:
+        mnt_drop_write_file(file);
+        return ret;
 }
 
-static void get_block_group_info(struct list_head *groups_list,
-                                 struct btrfs_ioctl_space_info *space)
+void btrfs_get_block_group_info(struct list_head *groups_list,
+                                struct btrfs_ioctl_space_info *space)
 {
         struct btrfs_block_group_cache *block_group;
 
@@ -2959,8 +3045,8 @@ long btrfs_ioctl_space_info(struct btrfs_root *root, void __user *arg)
                 down_read(&info->groups_sem);
                 for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
                         if (!list_empty(&info->block_groups[c])) {
-                                get_block_group_info(&info->block_groups[c],
-                                                     &space);
+                                btrfs_get_block_group_info(
+                                        &info->block_groups[c], &space);
                                 memcpy(dest, &space, sizeof(space));
                                 dest++;
                                 space_args.total_spaces++;
@@ -3011,32 +3097,38 @@ long btrfs_ioctl_trans_end(struct file *file)
         return 0;
 }
 
-static noinline long btrfs_ioctl_start_sync(struct file *file, void __user *argp)
+static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
+                                            void __user *argp)
 {
-        struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
         struct btrfs_trans_handle *trans;
         u64 transid;
         int ret;
 
-        trans = btrfs_start_transaction(root, 0);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
+        trans = btrfs_attach_transaction(root);
+        if (IS_ERR(trans)) {
+                if (PTR_ERR(trans) != -ENOENT)
+                        return PTR_ERR(trans);
+
+                /* No running transaction, don't bother */
+                transid = root->fs_info->last_trans_committed;
+                goto out;
+        }
         transid = trans->transid;
         ret = btrfs_commit_transaction_async(trans, root, 0);
         if (ret) {
                 btrfs_end_transaction(trans, root);
                 return ret;
         }
-
+out:
         if (argp)
                 if (copy_to_user(argp, &transid, sizeof(transid)))
                         return -EFAULT;
         return 0;
 }
 
-static noinline long btrfs_ioctl_wait_sync(struct file *file, void __user *argp)
+static noinline long btrfs_ioctl_wait_sync(struct btrfs_root *root,
+                                           void __user *argp)
 {
-        struct btrfs_root *root = BTRFS_I(file->f_dentry->d_inode)->root;
         u64 transid;
 
         if (argp) {
@@ -3048,10 +3140,11 @@ static noinline long btrfs_ioctl_wait_sync(struct file *file, void __user *argp)
         return btrfs_wait_for_commit(root, transid);
 }
 
-static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_scrub(struct file *file, void __user *arg)
 {
-        int ret;
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_scrub_args *sa;
+        int ret;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -3060,12 +3153,22 @@ static long btrfs_ioctl_scrub(struct btrfs_root *root, void __user *arg)
         if (IS_ERR(sa))
                 return PTR_ERR(sa);
 
-        ret = btrfs_scrub_dev(root, sa->devid, sa->start, sa->end,
-                              &sa->progress, sa->flags & BTRFS_SCRUB_READONLY);
+        if (!(sa->flags & BTRFS_SCRUB_READONLY)) {
+                ret = mnt_want_write_file(file);
+                if (ret)
+                        goto out;
+        }
+
+        ret = btrfs_scrub_dev(root->fs_info, sa->devid, sa->start, sa->end,
+                              &sa->progress, sa->flags & BTRFS_SCRUB_READONLY,
+                              0);
 
         if (copy_to_user(arg, sa, sizeof(*sa)))
                 ret = -EFAULT;
 
+        if (!(sa->flags & BTRFS_SCRUB_READONLY))
+                mnt_drop_write_file(file);
+out:
         kfree(sa);
         return ret;
 }
@@ -3075,7 +3178,7 @@ static long btrfs_ioctl_scrub_cancel(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        return btrfs_scrub_cancel(root);
+        return btrfs_scrub_cancel(root->fs_info);
 }
 
 static long btrfs_ioctl_scrub_progress(struct btrfs_root *root,
@@ -3124,6 +3227,51 @@ static long btrfs_ioctl_get_dev_stats(struct btrfs_root *root,
         return ret;
 }
 
+static long btrfs_ioctl_dev_replace(struct btrfs_root *root, void __user *arg)
+{
+        struct btrfs_ioctl_dev_replace_args *p;
+        int ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        p = memdup_user(arg, sizeof(*p));
+        if (IS_ERR(p))
+                return PTR_ERR(p);
+
+        switch (p->cmd) {
+        case BTRFS_IOCTL_DEV_REPLACE_CMD_START:
+                if (atomic_xchg(
+                        &root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                        pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
+                        ret = -EINPROGRESS;
+                } else {
+                        ret = btrfs_dev_replace_start(root, p);
+                        atomic_set(
+                         &root->fs_info->mutually_exclusive_operation_running,
+                         0);
+                }
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS:
+                btrfs_dev_replace_status(root->fs_info, p);
+                ret = 0;
+                break;
+        case BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL:
+                ret = btrfs_dev_replace_cancel(root->fs_info, p);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        if (copy_to_user(arg, p, sizeof(*p)))
+                ret = -EFAULT;
+
+        kfree(p);
+        return ret;
+}
+
 static long btrfs_ioctl_ino_to_path(struct btrfs_root *root, void __user *arg)
 {
         int ret = 0;
@@ -3208,11 +3356,9 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
 {
         int ret = 0;
         int size;
-        u64 extent_item_pos;
         struct btrfs_ioctl_logical_ino_args *loi;
         struct btrfs_data_container *inodes = NULL;
         struct btrfs_path *path = NULL;
-        struct btrfs_key key;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -3230,7 +3376,7 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
                 goto out;
         }
 
-        size = min_t(u32, loi->size, 4096);
+        size = min_t(u32, loi->size, 64 * 1024);
         inodes = init_data_container(size);
         if (IS_ERR(inodes)) {
                 ret = PTR_ERR(inodes);
@@ -3238,22 +3384,13 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
                 goto out;
         }
 
-        ret = extent_from_logical(root->fs_info, loi->logical, path, &key);
-        btrfs_release_path(path);
-
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK)
+        ret = iterate_inodes_from_logical(loi->logical, root->fs_info, path,
+                                          build_ino_list, inodes);
+        if (ret == -EINVAL)
                 ret = -ENOENT;
         if (ret < 0)
                 goto out;
 
-        extent_item_pos = loi->logical - key.objectid;
-        ret = iterate_extent_inodes(root->fs_info, key.objectid,
-                                        extent_item_pos, 0, build_ino_list,
-                                        inodes);
-
-        if (ret < 0)
-                goto out;
-
         ret = copy_to_user((void *)(unsigned long)loi->inodes,
                            (void *)(unsigned long)inodes, size);
         if (ret)
@@ -3261,7 +3398,7 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
 
 out:
         btrfs_free_path(path);
-        kfree(inodes);
+        vfree(inodes);
         kfree(loi);
 
         return ret;
@@ -3301,6 +3438,7 @@ static long btrfs_ioctl_balance(struct file *file, void __user *arg)
         struct btrfs_ioctl_balance_args *bargs;
         struct btrfs_balance_control *bctl;
         int ret;
+        int need_to_clear_lock = 0;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -3336,10 +3474,13 @@ static long btrfs_ioctl_balance(struct file *file, void __user *arg)
                 bargs = NULL;
         }
 
-        if (fs_info->balance_ctl) {
+        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
+                        1)) {
+                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
                 ret = -EINPROGRESS;
                 goto out_bargs;
         }
+        need_to_clear_lock = 1;
 
         bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
         if (!bctl) {
@@ -3373,6 +3514,9 @@ do_balance:
 out_bargs:
         kfree(bargs);
 out:
+        if (need_to_clear_lock)
+                atomic_set(&root->fs_info->mutually_exclusive_operation_running,
+                           0);
         mutex_unlock(&fs_info->balance_mutex);
         mutex_unlock(&fs_info->volume_mutex);
         mnt_drop_write_file(file);
@@ -3427,8 +3571,9 @@ out:
         return ret;
 }
 
-static long btrfs_ioctl_quota_ctl(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
 {
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_quota_ctl_args *sa;
         struct btrfs_trans_handle *trans = NULL;
         int ret;
@@ -3437,12 +3582,15 @@ static long btrfs_ioctl_quota_ctl(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
 
         sa = memdup_user(arg, sizeof(*sa));
-        if (IS_ERR(sa))
-                return PTR_ERR(sa);
+        if (IS_ERR(sa)) {
+                ret = PTR_ERR(sa);
+                goto drop_write;
+        }
 
         if (sa->cmd != BTRFS_QUOTA_CTL_RESCAN) {
                 trans = btrfs_start_transaction(root, 2);
@@ -3475,14 +3623,16 @@ static long btrfs_ioctl_quota_ctl(struct btrfs_root *root, void __user *arg)
                 if (err && !ret)
                         ret = err;
         }
-
 out:
         kfree(sa);
+drop_write:
+        mnt_drop_write_file(file);
         return ret;
 }
 
-static long btrfs_ioctl_qgroup_assign(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
 {
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_qgroup_assign_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3491,12 +3641,15 @@ static long btrfs_ioctl_qgroup_assign(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
 
         sa = memdup_user(arg, sizeof(*sa));
-        if (IS_ERR(sa))
-                return PTR_ERR(sa);
+        if (IS_ERR(sa)) {
+                ret = PTR_ERR(sa);
+                goto drop_write;
+        }
 
         trans = btrfs_join_transaction(root);
         if (IS_ERR(trans)) {
@@ -3519,11 +3672,14 @@ static long btrfs_ioctl_qgroup_assign(struct btrfs_root *root, void __user *arg)
 
 out:
         kfree(sa);
+drop_write:
+        mnt_drop_write_file(file);
         return ret;
 }
 
-static long btrfs_ioctl_qgroup_create(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
 {
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_qgroup_create_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3532,12 +3688,15 @@ static long btrfs_ioctl_qgroup_create(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
 
         sa = memdup_user(arg, sizeof(*sa));
-        if (IS_ERR(sa))
-                return PTR_ERR(sa);
+        if (IS_ERR(sa)) {
+                ret = PTR_ERR(sa);
+                goto drop_write;
+        }
 
         trans = btrfs_join_transaction(root);
         if (IS_ERR(trans)) {
@@ -3559,11 +3718,14 @@ static long btrfs_ioctl_qgroup_create(struct btrfs_root *root, void __user *arg)
 
 out:
         kfree(sa);
+drop_write:
+        mnt_drop_write_file(file);
         return ret;
 }
 
-static long btrfs_ioctl_qgroup_limit(struct btrfs_root *root, void __user *arg)
+static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
 {
+        struct btrfs_root *root = BTRFS_I(fdentry(file)->d_inode)->root;
         struct btrfs_ioctl_qgroup_limit_args *sa;
         struct btrfs_trans_handle *trans;
         int ret;
@@ -3573,12 +3735,15 @@ static long btrfs_ioctl_qgroup_limit(struct btrfs_root *root, void __user *arg)
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        if (root->fs_info->sb->s_flags & MS_RDONLY)
-                return -EROFS;
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
 
         sa = memdup_user(arg, sizeof(*sa));
-        if (IS_ERR(sa))
-                return PTR_ERR(sa);
+        if (IS_ERR(sa)) {
+                ret = PTR_ERR(sa);
+                goto drop_write;
+        }
 
         trans = btrfs_join_transaction(root);
         if (IS_ERR(trans)) {
@@ -3601,6 +3766,8 @@ static long btrfs_ioctl_qgroup_limit(struct btrfs_root *root, void __user *arg)
 
 out:
         kfree(sa);
+drop_write:
+        mnt_drop_write_file(file);
         return ret;
 }
 
@@ -3721,11 +3888,11 @@ long btrfs_ioctl(struct file *file, unsigned int
         case BTRFS_IOC_DEFRAG_RANGE:
                 return btrfs_ioctl_defrag(file, argp);
         case BTRFS_IOC_RESIZE:
-                return btrfs_ioctl_resize(root, argp);
+                return btrfs_ioctl_resize(file, argp);
         case BTRFS_IOC_ADD_DEV:
                 return btrfs_ioctl_add_dev(root, argp);
         case BTRFS_IOC_RM_DEV:
-                return btrfs_ioctl_rm_dev(root, argp);
+                return btrfs_ioctl_rm_dev(file, argp);
         case BTRFS_IOC_FS_INFO:
                 return btrfs_ioctl_fs_info(root, argp);
         case BTRFS_IOC_DEV_INFO:
@@ -3754,11 +3921,11 @@ long btrfs_ioctl(struct file *file, unsigned int
                 btrfs_sync_fs(file->f_dentry->d_sb, 1);
                 return 0;
         case BTRFS_IOC_START_SYNC:
-                return btrfs_ioctl_start_sync(file, argp);
+                return btrfs_ioctl_start_sync(root, argp);
         case BTRFS_IOC_WAIT_SYNC:
-                return btrfs_ioctl_wait_sync(file, argp);
+                return btrfs_ioctl_wait_sync(root, argp);
         case BTRFS_IOC_SCRUB:
-                return btrfs_ioctl_scrub(root, argp);
+                return btrfs_ioctl_scrub(file, argp);
         case BTRFS_IOC_SCRUB_CANCEL:
                 return btrfs_ioctl_scrub_cancel(root, argp);
         case BTRFS_IOC_SCRUB_PROGRESS:
@@ -3776,13 +3943,15 @@ long btrfs_ioctl(struct file *file, unsigned int
         case BTRFS_IOC_GET_DEV_STATS:
                 return btrfs_ioctl_get_dev_stats(root, argp);
         case BTRFS_IOC_QUOTA_CTL:
-                return btrfs_ioctl_quota_ctl(root, argp);
+                return btrfs_ioctl_quota_ctl(file, argp);
         case BTRFS_IOC_QGROUP_ASSIGN:
-                return btrfs_ioctl_qgroup_assign(root, argp);
+                return btrfs_ioctl_qgroup_assign(file, argp);
         case BTRFS_IOC_QGROUP_CREATE:
-                return btrfs_ioctl_qgroup_create(root, argp);
+                return btrfs_ioctl_qgroup_create(file, argp);
         case BTRFS_IOC_QGROUP_LIMIT:
-                return btrfs_ioctl_qgroup_limit(root, argp);
+                return btrfs_ioctl_qgroup_limit(file, argp);
+        case BTRFS_IOC_DEV_REPLACE:
+                return btrfs_ioctl_dev_replace(root, argp);
         }
 
         return -ENOTTY;
diff --git a/fs/btrfs/ioctl.h b/fs/btrfs/ioctl.h
index 731e2875ab93..dabca9cc8c2e 100644
--- a/fs/btrfs/ioctl.h
+++ b/fs/btrfs/ioctl.h
@@ -30,6 +30,8 @@ struct btrfs_ioctl_vol_args {
         char name[BTRFS_PATH_NAME_MAX + 1];
 };
 
+#define BTRFS_DEVICE_PATH_NAME_MAX 1024
+
 #define BTRFS_SUBVOL_CREATE_ASYNC       (1ULL << 0)
 #define BTRFS_SUBVOL_RDONLY             (1ULL << 1)
 #define BTRFS_SUBVOL_QGROUP_INHERIT     (1ULL << 2)
@@ -123,7 +125,48 @@ struct btrfs_ioctl_scrub_args {
         __u64 unused[(1024-32-sizeof(struct btrfs_scrub_progress))/8];
 };
 
-#define BTRFS_DEVICE_PATH_NAME_MAX 1024
+#define BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS    0
+#define BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID     1
+struct btrfs_ioctl_dev_replace_start_params {
+        __u64 srcdevid; /* in, if 0, use srcdev_name instead */
+        __u64 cont_reading_from_srcdev_mode;    /* in, see #define
+                                                 * above */
+        __u8 srcdev_name[BTRFS_DEVICE_PATH_NAME_MAX + 1];       /* in */
+        __u8 tgtdev_name[BTRFS_DEVICE_PATH_NAME_MAX + 1];       /* in */
+};
+
+#define BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED     0
+#define BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED           1
+#define BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED          2
+#define BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED          3
+#define BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED         4
+struct btrfs_ioctl_dev_replace_status_params {
+        __u64 replace_state;    /* out, see #define above */
+        __u64 progress_1000;    /* out, 0 <= x <= 1000 */
+        __u64 time_started;     /* out, seconds since 1-Jan-1970 */
+        __u64 time_stopped;     /* out, seconds since 1-Jan-1970 */
+        __u64 num_write_errors; /* out */
+        __u64 num_uncorrectable_read_errors;    /* out */
+};
+
+#define BTRFS_IOCTL_DEV_REPLACE_CMD_START                       0
+#define BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS                      1
+#define BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL                      2
+#define BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR                 0
+#define BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED              1
+#define BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED          2
+struct btrfs_ioctl_dev_replace_args {
+        __u64 cmd;      /* in */
+        __u64 result;   /* out */
+
+        union {
+                struct btrfs_ioctl_dev_replace_start_params start;
+                struct btrfs_ioctl_dev_replace_status_params status;
+        };      /* in/out */
+
+        __u64 spare[64];
+};
+
 struct btrfs_ioctl_dev_info_args {
         __u64 devid;                            /* in/out */
         __u8 uuid[BTRFS_UUID_SIZE];             /* in/out */
@@ -453,4 +496,7 @@ struct btrfs_ioctl_send_args {
                                struct btrfs_ioctl_qgroup_limit_args)
 #define BTRFS_IOC_GET_DEV_STATS _IOWR(BTRFS_IOCTL_MAGIC, 52, \
                                       struct btrfs_ioctl_get_dev_stats)
+#define BTRFS_IOC_DEV_REPLACE _IOWR(BTRFS_IOCTL_MAGIC, 53, \
+                                    struct btrfs_ioctl_dev_replace_args)
+
 #endif
diff --git a/fs/btrfs/math.h b/fs/btrfs/math.h
new file mode 100644
index 000000000000..b7816cefbd13
--- /dev/null
+++ b/fs/btrfs/math.h
@@ -0,0 +1,44 @@
+
+/*
+ * Copyright (C) 2012 Fujitsu.  All rights reserved.
+ * Written by Miao Xie <miaox@cn.fujitsu.com>
+ *
+ * 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.
+ */
+
+#ifndef __BTRFS_MATH_H
+#define __BTRFS_MATH_H
+
+#include <asm/div64.h>
+
+static inline u64 div_factor(u64 num, int factor)
+{
+        if (factor == 10)
+                return num;
+        num *= factor;
+        do_div(num, 10);
+        return num;
+}
+
+static inline u64 div_factor_fine(u64 num, int factor)
+{
+        if (factor == 100)
+                return num;
+        num *= factor;
+        do_div(num, 100);
+        return num;
+}
+
+#endif
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 051c7fe551dd..f10731297040 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -25,6 +25,8 @@
 #include "btrfs_inode.h"
 #include "extent_io.h"
 
+static struct kmem_cache *btrfs_ordered_extent_cache;
+
 static u64 entry_end(struct btrfs_ordered_extent *entry)
 {
         if (entry->file_offset + entry->len < entry->file_offset)
@@ -187,7 +189,7 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
         struct btrfs_ordered_extent *entry;
 
         tree = &BTRFS_I(inode)->ordered_tree;
-        entry = kzalloc(sizeof(*entry), GFP_NOFS);
+        entry = kmem_cache_zalloc(btrfs_ordered_extent_cache, GFP_NOFS);
         if (!entry)
                 return -ENOMEM;
 
@@ -209,6 +211,8 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
         init_waitqueue_head(&entry->wait);
         INIT_LIST_HEAD(&entry->list);
         INIT_LIST_HEAD(&entry->root_extent_list);
+        INIT_LIST_HEAD(&entry->work_list);
+        init_completion(&entry->completion);
 
         trace_btrfs_ordered_extent_add(inode, entry);
 
@@ -421,7 +425,7 @@ void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
                         list_del(&sum->list);
                         kfree(sum);
                 }
-                kfree(entry);
+                kmem_cache_free(btrfs_ordered_extent_cache, entry);
         }
 }
 
@@ -462,19 +466,28 @@ void btrfs_remove_ordered_extent(struct inode *inode,
         wake_up(&entry->wait);
 }
 
+static void btrfs_run_ordered_extent_work(struct btrfs_work *work)
+{
+        struct btrfs_ordered_extent *ordered;
+
+        ordered = container_of(work, struct btrfs_ordered_extent, flush_work);
+        btrfs_start_ordered_extent(ordered->inode, ordered, 1);
+        complete(&ordered->completion);
+}
+
 /*
  * 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 nocow_only, int delay_iput)
+void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput)
 {
-        struct list_head splice;
+        struct list_head splice, works;
         struct list_head *cur;
-        struct btrfs_ordered_extent *ordered;
+        struct btrfs_ordered_extent *ordered, *next;
         struct inode *inode;
 
         INIT_LIST_HEAD(&splice);
+        INIT_LIST_HEAD(&works);
 
         spin_lock(&root->fs_info->ordered_extent_lock);
         list_splice_init(&root->fs_info->ordered_extents, &splice);
@@ -482,15 +495,6 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root,
                 cur = splice.next;
                 ordered = list_entry(cur, struct btrfs_ordered_extent,
                                      root_extent_list);
-                if (nocow_only &&
-                    !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) &&
-                    !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
-                        list_move(&ordered->root_extent_list,
-                                  &root->fs_info->ordered_extents);
-                        cond_resched_lock(&root->fs_info->ordered_extent_lock);
-                        continue;
-                }
-
                 list_del_init(&ordered->root_extent_list);
                 atomic_inc(&ordered->refs);
 
@@ -502,19 +506,32 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root,
                 spin_unlock(&root->fs_info->ordered_extent_lock);
 
                 if (inode) {
-                        btrfs_start_ordered_extent(inode, ordered, 1);
-                        btrfs_put_ordered_extent(ordered);
-                        if (delay_iput)
-                                btrfs_add_delayed_iput(inode);
-                        else
-                                iput(inode);
+                        ordered->flush_work.func = btrfs_run_ordered_extent_work;
+                        list_add_tail(&ordered->work_list, &works);
+                        btrfs_queue_worker(&root->fs_info->flush_workers,
+                                           &ordered->flush_work);
                 } else {
                         btrfs_put_ordered_extent(ordered);
                 }
 
+                cond_resched();
                 spin_lock(&root->fs_info->ordered_extent_lock);
         }
         spin_unlock(&root->fs_info->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();
+        }
 }
 
 /*
@@ -527,13 +544,17 @@ void btrfs_wait_ordered_extents(struct btrfs_root *root,
  * extra check to make sure the ordered operation list really is empty
  * before we return
  */
-void btrfs_run_ordered_operations(struct btrfs_root *root, int wait)
+int btrfs_run_ordered_operations(struct btrfs_root *root, int wait)
 {
         struct btrfs_inode *btrfs_inode;
         struct inode *inode;
         struct list_head splice;
+        struct list_head works;
+        struct btrfs_delalloc_work *work, *next;
+        int ret = 0;
 
         INIT_LIST_HEAD(&splice);
+        INIT_LIST_HEAD(&works);
 
         mutex_lock(&root->fs_info->ordered_operations_mutex);
         spin_lock(&root->fs_info->ordered_extent_lock);
@@ -541,6 +562,7 @@ again:
         list_splice_init(&root->fs_info->ordered_operations, &splice);
 
         while (!list_empty(&splice)) {
+
                 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
                                    ordered_operations);
 
@@ -557,15 +579,26 @@ again:
                         list_add_tail(&BTRFS_I(inode)->ordered_operations,
                               &root->fs_info->ordered_operations);
                 }
+
+                if (!inode)
+                        continue;
                 spin_unlock(&root->fs_info->ordered_extent_lock);
 
-                if (inode) {
-                        if (wait)
-                                btrfs_wait_ordered_range(inode, 0, (u64)-1);
-                        else
-                                filemap_flush(inode->i_mapping);
-                        btrfs_add_delayed_iput(inode);
+                work = btrfs_alloc_delalloc_work(inode, wait, 1);
+                if (!work) {
+                        if (list_empty(&BTRFS_I(inode)->ordered_operations))
+                                list_add_tail(&btrfs_inode->ordered_operations,
+                                              &splice);
+                        spin_lock(&root->fs_info->ordered_extent_lock);
+                        list_splice_tail(&splice,
+                                         &root->fs_info->ordered_operations);
+                        spin_unlock(&root->fs_info->ordered_extent_lock);
+                        ret = -ENOMEM;
+                        goto out;
                 }
+                list_add_tail(&work->list, &works);
+                btrfs_queue_worker(&root->fs_info->flush_workers,
+                                   &work->work);
 
                 cond_resched();
                 spin_lock(&root->fs_info->ordered_extent_lock);
@@ -574,7 +607,13 @@ again:
                 goto again;
 
         spin_unlock(&root->fs_info->ordered_extent_lock);
+out:
+        list_for_each_entry_safe(work, next, &works, list) {
+                list_del_init(&work->list);
+                btrfs_wait_and_free_delalloc_work(work);
+        }
         mutex_unlock(&root->fs_info->ordered_operations_mutex);
+        return ret;
 }
 
 /*
@@ -614,7 +653,6 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
         u64 end;
         u64 orig_end;
         struct btrfs_ordered_extent *ordered;
-        int found;
 
         if (start + len < start) {
                 orig_end = INT_LIMIT(loff_t);
@@ -650,7 +688,6 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
         filemap_fdatawait_range(inode->i_mapping, start, orig_end);
 
         end = orig_end;
-        found = 0;
         while (1) {
                 ordered = btrfs_lookup_first_ordered_extent(inode, end);
                 if (!ordered)
@@ -663,7 +700,6 @@ void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
                         btrfs_put_ordered_extent(ordered);
                         break;
                 }
-                found++;
                 btrfs_start_ordered_extent(inode, ordered, 1);
                 end = ordered->file_offset;
                 btrfs_put_ordered_extent(ordered);
@@ -775,7 +811,6 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
         struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
         u64 disk_i_size;
         u64 new_i_size;
-        u64 i_size_test;
         u64 i_size = i_size_read(inode);
         struct rb_node *node;
         struct rb_node *prev = NULL;
@@ -835,55 +870,30 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
                         break;
                 if (test->file_offset >= i_size)
                         break;
-                if (test->file_offset >= disk_i_size)
+                if (test->file_offset >= disk_i_size) {
+                        /*
+                         * we don't update disk_i_size now, so record this
+                         * undealt i_size. Or we will not know the real
+                         * i_size.
+                         */
+                        if (test->outstanding_isize < offset)
+                                test->outstanding_isize = offset;
+                        if (ordered &&
+                            ordered->outstanding_isize >
+                            test->outstanding_isize)
+                                test->outstanding_isize =
+                                                ordered->outstanding_isize;
                         goto out;
-        }
-        new_i_size = min_t(u64, offset, i_size);
-
-        /*
-         * at this point, we know we can safely update i_size to at least
-         * the offset from this ordered extent.  But, we need to
-         * walk forward and see if ios from higher up in the file have
-         * finished.
-         */
-        if (ordered) {
-                node = rb_next(&ordered->rb_node);
-        } else {
-                if (prev)
-                        node = rb_next(prev);
-                else
-                        node = rb_first(&tree->tree);
-        }
-
-        /*
-         * We are looking for an area between our current extent and the next
-         * ordered extent to update the i_size to.  There are 3 cases here
-         *
-         * 1) We don't actually have anything and we can update to i_size.
-         * 2) We have stuff but they already did their i_size update so again we
-         * can just update to i_size.
-         * 3) We have an outstanding ordered extent so the most we can update
-         * our disk_i_size to is the start of the next offset.
-         */
-        i_size_test = i_size;
-        for (; node; node = rb_next(node)) {
-                test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
-
-                if (test_bit(BTRFS_ORDERED_UPDATED_ISIZE, &test->flags))
-                        continue;
-                if (test->file_offset > offset) {
-                        i_size_test = test->file_offset;
-                        break;
                 }
         }
+        new_i_size = min_t(u64, offset, i_size);
 
         /*
-         * i_size_test is the end of a region after this ordered
-         * extent where there are no ordered extents, we can safely set
-         * disk_i_size to this.
+         * Some ordered extents may completed before the current one, and
+         * we hold the real i_size in ->outstanding_isize.
          */
-        if (i_size_test > offset)
-                new_i_size = min_t(u64, i_size_test, i_size);
+        if (ordered && ordered->outstanding_isize > new_i_size)
+                new_i_size = min_t(u64, ordered->outstanding_isize, i_size);
         BTRFS_I(inode)->disk_i_size = new_i_size;
         ret = 0;
 out:
@@ -968,15 +978,6 @@ void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
         if (last_mod < root->fs_info->last_trans_committed)
                 return;
 
-        /*
-         * the transaction is already committing.  Just start the IO and
-         * don't bother with all of this list nonsense
-         */
-        if (trans && root->fs_info->running_transaction->blocked) {
-                btrfs_wait_ordered_range(inode, 0, (u64)-1);
-                return;
-        }
-
         spin_lock(&root->fs_info->ordered_extent_lock);
         if (list_empty(&BTRFS_I(inode)->ordered_operations)) {
                 list_add_tail(&BTRFS_I(inode)->ordered_operations,
@@ -984,3 +985,21 @@ void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
         }
         spin_unlock(&root->fs_info->ordered_extent_lock);
 }
+
+int __init ordered_data_init(void)
+{
+        btrfs_ordered_extent_cache = kmem_cache_create("btrfs_ordered_extent",
+                                     sizeof(struct btrfs_ordered_extent), 0,
+                                     SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                                     NULL);
+        if (!btrfs_ordered_extent_cache)
+                return -ENOMEM;
+
+        return 0;
+}
+
+void ordered_data_exit(void)
+{
+        if (btrfs_ordered_extent_cache)
+                kmem_cache_destroy(btrfs_ordered_extent_cache);
+}
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index e03c560d2997..f29d4bf5fbe7 100644
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -76,7 +76,7 @@ struct btrfs_ordered_sum {
 
 #define BTRFS_ORDERED_IOERR 6 /* We had an io error when writing this out */
 
-#define BTRFS_ORDERED_UPDATED_ISIZE 7 /* indicates wether this ordered extent
+#define BTRFS_ORDERED_UPDATED_ISIZE 7 /* indicates whether this ordered extent
                                        * has done its due diligence in updating
                                        * the isize. */
 
@@ -96,6 +96,13 @@ struct btrfs_ordered_extent {
         /* number of bytes that still need writing */
         u64 bytes_left;
 
+        /*
+         * the end of the ordered extent which is behind it but
+         * didn't update disk_i_size. Please see the comment of
+         * btrfs_ordered_update_i_size();
+         */
+        u64 outstanding_isize;
+
         /* flags (described above) */
         unsigned long flags;
 
@@ -121,8 +128,11 @@ struct btrfs_ordered_extent {
         struct list_head root_extent_list;
 
         struct btrfs_work work;
-};
 
+        struct completion completion;
+        struct btrfs_work flush_work;
+        struct list_head work_list;
+};
 
 /*
  * calculates the total size you need to allocate for an ordered sum
@@ -179,10 +189,11 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode,
 int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
                                 struct btrfs_ordered_extent *ordered);
 int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr, u32 *sum);
-void btrfs_run_ordered_operations(struct btrfs_root *root, int wait);
+int btrfs_run_ordered_operations(struct btrfs_root *root, int wait);
 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 nocow_only, int delay_iput);
+void btrfs_wait_ordered_extents(struct btrfs_root *root, int delay_iput);
+int __init ordered_data_init(void);
+void ordered_data_exit(void);
 #endif
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index 5e23684887eb..50d95fd190a5 100644
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -297,6 +297,9 @@ void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
                 case BTRFS_DEV_STATS_KEY:
                         printk(KERN_INFO "\t\tdevice stats\n");
                         break;
+                case BTRFS_DEV_REPLACE_KEY:
+                        printk(KERN_INFO "\t\tdev replace\n");
+                        break;
                 };
         }
 }
diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index b65015581744..fe9d02c45f8e 100644
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -790,8 +790,10 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
         }
 
         path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
+        if (!path) {
+                ret = -ENOMEM;
+                goto out_free_root;
+        }
 
         key.objectid = 0;
         key.type = BTRFS_QGROUP_STATUS_KEY;
@@ -800,7 +802,7 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
         ret = btrfs_insert_empty_item(trans, quota_root, path, &key,
                                       sizeof(*ptr));
         if (ret)
-                goto out;
+                goto out_free_path;
 
         leaf = path->nodes[0];
         ptr = btrfs_item_ptr(leaf, path->slots[0],
@@ -818,8 +820,15 @@ int btrfs_quota_enable(struct btrfs_trans_handle *trans,
         fs_info->quota_root = quota_root;
         fs_info->pending_quota_state = 1;
         spin_unlock(&fs_info->qgroup_lock);
-out:
+out_free_path:
         btrfs_free_path(path);
+out_free_root:
+        if (ret) {
+                free_extent_buffer(quota_root->node);
+                free_extent_buffer(quota_root->commit_root);
+                kfree(quota_root);
+        }
+out:
         return ret;
 }
 
@@ -1145,12 +1154,12 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                 ulist_reinit(tmp);
                                                 /* XXX id not needed */
-                ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+                ulist_add(tmp, qg->qgroupid, (u64)(uintptr_t)qg, GFP_ATOMIC);
                 ULIST_ITER_INIT(&tmp_uiter);
                 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                         struct btrfs_qgroup_list *glist;
 
-                        qg = (struct btrfs_qgroup *)tmp_unode->aux;
+                        qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
                         if (qg->refcnt < seq)
                                 qg->refcnt = seq + 1;
                         else
@@ -1158,7 +1167,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                         list_for_each_entry(glist, &qg->groups, next_group) {
                                 ulist_add(tmp, glist->group->qgroupid,
-                                          (unsigned long)glist->group,
+                                          (u64)(uintptr_t)glist->group,
                                           GFP_ATOMIC);
                         }
                 }
@@ -1168,13 +1177,13 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
          * step 2: walk from the new root
          */
         ulist_reinit(tmp);
-        ulist_add(tmp, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        ulist_add(tmp, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(tmp, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
                 if (qg->refcnt < seq) {
                         /* not visited by step 1 */
                         qg->rfer += sgn * node->num_bytes;
@@ -1190,7 +1199,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(tmp, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
 
@@ -1208,12 +1217,12 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
                         continue;
 
                 ulist_reinit(tmp);
-                ulist_add(tmp, qg->qgroupid, (unsigned long)qg, GFP_ATOMIC);
+                ulist_add(tmp, qg->qgroupid, (uintptr_t)qg, GFP_ATOMIC);
                 ULIST_ITER_INIT(&tmp_uiter);
                 while ((tmp_unode = ulist_next(tmp, &tmp_uiter))) {
                         struct btrfs_qgroup_list *glist;
 
-                        qg = (struct btrfs_qgroup *)tmp_unode->aux;
+                        qg = (struct btrfs_qgroup *)(uintptr_t)tmp_unode->aux;
                         if (qg->tag == seq)
                                 continue;
 
@@ -1225,7 +1234,7 @@ int btrfs_qgroup_account_ref(struct btrfs_trans_handle *trans,
 
                         list_for_each_entry(glist, &qg->groups, next_group) {
                                 ulist_add(tmp, glist->group->qgroupid,
-                                          (unsigned long)glist->group,
+                                          (uintptr_t)glist->group,
                                           GFP_ATOMIC);
                         }
                 }
@@ -1469,13 +1478,17 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
          * be exceeded
          */
         ulist = ulist_alloc(GFP_ATOMIC);
-        ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        if (!ulist) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        ulist_add(ulist, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 if ((qg->lim_flags & BTRFS_QGROUP_LIMIT_MAX_RFER) &&
                     qg->reserved + qg->rfer + num_bytes >
@@ -1489,7 +1502,7 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(ulist, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
         if (ret)
@@ -1502,7 +1515,7 @@ int btrfs_qgroup_reserve(struct btrfs_root *root, u64 num_bytes)
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 qg->reserved += num_bytes;
         }
@@ -1541,19 +1554,23 @@ void btrfs_qgroup_free(struct btrfs_root *root, u64 num_bytes)
                 goto out;
 
         ulist = ulist_alloc(GFP_ATOMIC);
-        ulist_add(ulist, qgroup->qgroupid, (unsigned long)qgroup, GFP_ATOMIC);
+        if (!ulist) {
+                btrfs_std_error(fs_info, -ENOMEM);
+                goto out;
+        }
+        ulist_add(ulist, qgroup->qgroupid, (uintptr_t)qgroup, GFP_ATOMIC);
         ULIST_ITER_INIT(&uiter);
         while ((unode = ulist_next(ulist, &uiter))) {
                 struct btrfs_qgroup *qg;
                 struct btrfs_qgroup_list *glist;
 
-                qg = (struct btrfs_qgroup *)unode->aux;
+                qg = (struct btrfs_qgroup *)(uintptr_t)unode->aux;
 
                 qg->reserved -= num_bytes;
 
                 list_for_each_entry(glist, &qg->groups, next_group) {
                         ulist_add(ulist, glist->group->qgroupid,
-                                  (unsigned long)glist->group, GFP_ATOMIC);
+                                  (uintptr_t)glist->group, GFP_ATOMIC);
                 }
         }
 
diff --git a/fs/btrfs/reada.c b/fs/btrfs/reada.c
index a955669519a2..96b93daa0bbb 100644
--- a/fs/btrfs/reada.c
+++ b/fs/btrfs/reada.c
@@ -27,6 +27,7 @@
 #include "volumes.h"
 #include "disk-io.h"
 #include "transaction.h"
+#include "dev-replace.h"
 
 #undef DEBUG
 
@@ -323,7 +324,6 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
         struct reada_extent *re = NULL;
         struct reada_extent *re_exist = NULL;
         struct btrfs_fs_info *fs_info = root->fs_info;
-        struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
         struct btrfs_bio *bbio = NULL;
         struct btrfs_device *dev;
         struct btrfs_device *prev_dev;
@@ -332,6 +332,7 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
         int nzones = 0;
         int i;
         unsigned long index = logical >> PAGE_CACHE_SHIFT;
+        int dev_replace_is_ongoing;
 
         spin_lock(&fs_info->reada_lock);
         re = radix_tree_lookup(&fs_info->reada_tree, index);
@@ -358,7 +359,8 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
          * map block
          */
         length = blocksize;
-        ret = btrfs_map_block(map_tree, REQ_WRITE, logical, &length, &bbio, 0);
+        ret = btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS, logical, &length,
+                              &bbio, 0);
         if (ret || !bbio || length < blocksize)
                 goto error;
 
@@ -393,6 +395,7 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
         }
 
         /* insert extent in reada_tree + all per-device trees, all or nothing */
+        btrfs_dev_replace_lock(&fs_info->dev_replace);
         spin_lock(&fs_info->reada_lock);
         ret = radix_tree_insert(&fs_info->reada_tree, index, re);
         if (ret == -EEXIST) {
@@ -400,13 +403,17 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
                 BUG_ON(!re_exist);
                 re_exist->refcnt++;
                 spin_unlock(&fs_info->reada_lock);
+                btrfs_dev_replace_unlock(&fs_info->dev_replace);
                 goto error;
         }
         if (ret) {
                 spin_unlock(&fs_info->reada_lock);
+                btrfs_dev_replace_unlock(&fs_info->dev_replace);
                 goto error;
         }
         prev_dev = NULL;
+        dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(
+                        &fs_info->dev_replace);
         for (i = 0; i < nzones; ++i) {
                 dev = bbio->stripes[i].dev;
                 if (dev == prev_dev) {
@@ -419,21 +426,36 @@ static struct reada_extent *reada_find_extent(struct btrfs_root *root,
                          */
                         continue;
                 }
+                if (!dev->bdev) {
+                        /* cannot read ahead on missing device */
+                        continue;
+                }
+                if (dev_replace_is_ongoing &&
+                    dev == fs_info->dev_replace.tgtdev) {
+                        /*
+                         * as this device is selected for reading only as
+                         * a last resort, skip it for read ahead.
+                         */
+                        continue;
+                }
                 prev_dev = dev;
                 ret = radix_tree_insert(&dev->reada_extents, index, re);
                 if (ret) {
                         while (--i >= 0) {
                                 dev = bbio->stripes[i].dev;
                                 BUG_ON(dev == NULL);
+                                /* ignore whether the entry was inserted */
                                 radix_tree_delete(&dev->reada_extents, index);
                         }
                         BUG_ON(fs_info == NULL);
                         radix_tree_delete(&fs_info->reada_tree, index);
                         spin_unlock(&fs_info->reada_lock);
+                        btrfs_dev_replace_unlock(&fs_info->dev_replace);
                         goto error;
                 }
         }
         spin_unlock(&fs_info->reada_lock);
+        btrfs_dev_replace_unlock(&fs_info->dev_replace);
 
         kfree(bbio);
         return re;
@@ -915,7 +937,10 @@ struct reada_control *btrfs_reada_add(struct btrfs_root *root,
         generation = btrfs_header_generation(node);
         free_extent_buffer(node);
 
-        reada_add_block(rc, start, &max_key, level, generation);
+        if (reada_add_block(rc, start, &max_key, level, generation)) {
+                kfree(rc);
+                return ERR_PTR(-ENOMEM);
+        }
 
         reada_start_machine(root->fs_info);
 
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 4da08652004d..300e09ac3659 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2025,7 +2025,6 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
         struct btrfs_root_item *root_item;
         struct btrfs_path *path;
         struct extent_buffer *leaf;
-        unsigned long nr;
         int level;
         int max_level;
         int replaced = 0;
@@ -2074,7 +2073,8 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
                 BUG_ON(IS_ERR(trans));
                 trans->block_rsv = rc->block_rsv;
 
-                ret = btrfs_block_rsv_refill(root, rc->block_rsv, min_reserved);
+                ret = btrfs_block_rsv_refill(root, rc->block_rsv, min_reserved,
+                                             BTRFS_RESERVE_FLUSH_ALL);
                 if (ret) {
                         BUG_ON(ret != -EAGAIN);
                         ret = btrfs_commit_transaction(trans, root);
@@ -2125,10 +2125,9 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
                                path->slots[level]);
                 root_item->drop_level = level;
 
-                nr = trans->blocks_used;
                 btrfs_end_transaction_throttle(trans, root);
 
-                btrfs_btree_balance_dirty(root, nr);
+                btrfs_btree_balance_dirty(root);
 
                 if (replaced && rc->stage == UPDATE_DATA_PTRS)
                         invalidate_extent_cache(root, &key, &next_key);
@@ -2155,10 +2154,9 @@ out:
                 btrfs_update_reloc_root(trans, root);
         }
 
-        nr = trans->blocks_used;
         btrfs_end_transaction_throttle(trans, root);
 
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
 
         if (replaced && rc->stage == UPDATE_DATA_PTRS)
                 invalidate_extent_cache(root, &key, &next_key);
@@ -2184,7 +2182,8 @@ int prepare_to_merge(struct reloc_control *rc, int err)
 again:
         if (!err) {
                 num_bytes = rc->merging_rsv_size;
-                ret = btrfs_block_rsv_add(root, rc->block_rsv, num_bytes);
+                ret = btrfs_block_rsv_add(root, rc->block_rsv, num_bytes,
+                                          BTRFS_RESERVE_FLUSH_ALL);
                 if (ret)
                         err = ret;
         }
@@ -2459,7 +2458,8 @@ static int reserve_metadata_space(struct btrfs_trans_handle *trans,
         num_bytes = calcu_metadata_size(rc, node, 1) * 2;
 
         trans->block_rsv = rc->block_rsv;
-        ret = btrfs_block_rsv_add(root, rc->block_rsv, num_bytes);
+        ret = btrfs_block_rsv_add(root, rc->block_rsv, num_bytes,
+                                  BTRFS_RESERVE_FLUSH_ALL);
         if (ret) {
                 if (ret == -EAGAIN)
                         rc->commit_transaction = 1;
@@ -3259,7 +3259,6 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info,
         struct btrfs_path *path;
         struct btrfs_root *root = fs_info->tree_root;
         struct btrfs_trans_handle *trans;
-        unsigned long nr;
         int ret = 0;
 
         if (inode)
@@ -3270,8 +3269,8 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info,
         key.offset = 0;
 
         inode = btrfs_iget(fs_info->sb, &key, root, NULL);
-        if (IS_ERR_OR_NULL(inode) || is_bad_inode(inode)) {
-                if (inode && !IS_ERR(inode))
+        if (IS_ERR(inode) || is_bad_inode(inode)) {
+                if (!IS_ERR(inode))
                         iput(inode);
                 return -ENOENT;
         }
@@ -3293,9 +3292,8 @@ truncate:
         ret = btrfs_truncate_free_space_cache(root, trans, path, inode);
 
         btrfs_free_path(path);
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
 out:
         iput(inode);
         return ret;
@@ -3621,7 +3619,7 @@ next:
 
                 ret = find_first_extent_bit(&rc->processed_blocks,
                                             key.objectid, &start, &end,
-                                            EXTENT_DIRTY);
+                                            EXTENT_DIRTY, NULL);
 
                 if (ret == 0 && start <= key.objectid) {
                         btrfs_release_path(path);
@@ -3674,7 +3672,8 @@ int prepare_to_relocate(struct reloc_control *rc)
         struct btrfs_trans_handle *trans;
         int ret;
 
-        rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root);
+        rc->block_rsv = btrfs_alloc_block_rsv(rc->extent_root,
+                                              BTRFS_BLOCK_RSV_TEMP);
         if (!rc->block_rsv)
                 return -ENOMEM;
 
@@ -3684,7 +3683,8 @@ int prepare_to_relocate(struct reloc_control *rc)
          * is no reservation in transaction handle.
          */
         ret = btrfs_block_rsv_add(rc->extent_root, rc->block_rsv,
-                                  rc->extent_root->nodesize * 256);
+                                  rc->extent_root->nodesize * 256,
+                                  BTRFS_RESERVE_FLUSH_ALL);
         if (ret)
                 return ret;
 
@@ -3710,7 +3710,6 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
         struct btrfs_trans_handle *trans = NULL;
         struct btrfs_path *path;
         struct btrfs_extent_item *ei;
-        unsigned long nr;
         u64 flags;
         u32 item_size;
         int ret;
@@ -3827,9 +3826,8 @@ restart:
                         ret = btrfs_commit_transaction(trans, rc->extent_root);
                         BUG_ON(ret);
                 } else {
-                        nr = trans->blocks_used;
                         btrfs_end_transaction_throttle(trans, rc->extent_root);
-                        btrfs_btree_balance_dirty(rc->extent_root, nr);
+                        btrfs_btree_balance_dirty(rc->extent_root);
                 }
                 trans = NULL;
 
@@ -3859,9 +3857,8 @@ restart:
                           GFP_NOFS);
 
         if (trans) {
-                nr = trans->blocks_used;
                 btrfs_end_transaction_throttle(trans, rc->extent_root);
-                btrfs_btree_balance_dirty(rc->extent_root, nr);
+                btrfs_btree_balance_dirty(rc->extent_root);
         }
 
         if (!err) {
@@ -3940,7 +3937,6 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root;
         struct btrfs_key key;
-        unsigned long nr;
         u64 objectid = BTRFS_FIRST_FREE_OBJECTID;
         int err = 0;
 
@@ -3968,9 +3964,8 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
 
         err = btrfs_orphan_add(trans, inode);
 out:
-        nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
+        btrfs_btree_balance_dirty(root);
         if (err) {
                 if (inode)
                         iput(inode);
@@ -4056,8 +4051,12 @@ int btrfs_relocate_block_group(struct btrfs_root *extent_root, u64 group_start)
                (unsigned long long)rc->block_group->key.objectid,
                (unsigned long long)rc->block_group->flags);
 
-        btrfs_start_delalloc_inodes(fs_info->tree_root, 0);
-        btrfs_wait_ordered_extents(fs_info->tree_root, 0, 0);
+        ret = btrfs_start_delalloc_inodes(fs_info->tree_root, 0);
+        if (ret < 0) {
+                err = ret;
+                goto out;
+        }
+        btrfs_wait_ordered_extents(fs_info->tree_root, 0);
 
         while (1) {
                 mutex_lock(&fs_info->cleaner_mutex);
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 10d8e4d88071..668af537a3ea 100644
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -141,8 +141,10 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
                 return -ENOMEM;
 
         ret = btrfs_search_slot(trans, root, key, path, 0, 1);
-        if (ret < 0)
-                goto out_abort;
+        if (ret < 0) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         if (ret != 0) {
                 btrfs_print_leaf(root, path->nodes[0]);
@@ -166,16 +168,23 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
                 btrfs_release_path(path);
                 ret = btrfs_search_slot(trans, root, key, path,
                                 -1, 1);
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
+
                 ret = btrfs_del_item(trans, root, path);
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
                 btrfs_release_path(path);
                 ret = btrfs_insert_empty_item(trans, root, path,
                                 key, sizeof(*item));
-                if (ret < 0)
-                        goto out_abort;
+                if (ret < 0) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        goto out;
+                }
                 l = path->nodes[0];
                 slot = path->slots[0];
                 ptr = btrfs_item_ptr_offset(l, slot);
@@ -192,10 +201,6 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root
 out:
         btrfs_free_path(path);
         return ret;
-
-out_abort:
-        btrfs_abort_transaction(trans, root, ret);
-        goto out;
 }
 
 int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root,
@@ -543,9 +548,9 @@ void btrfs_update_root_times(struct btrfs_trans_handle *trans,
         struct btrfs_root_item *item = &root->root_item;
         struct timespec ct = CURRENT_TIME;
 
-        spin_lock(&root->root_times_lock);
+        spin_lock(&root->root_item_lock);
         item->ctransid = cpu_to_le64(trans->transid);
         item->ctime.sec = cpu_to_le64(ct.tv_sec);
         item->ctime.nsec = cpu_to_le32(ct.tv_nsec);
-        spin_unlock(&root->root_times_lock);
+        spin_unlock(&root->root_item_lock);
 }
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index b223620cd5a6..bdbb94f245c9 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 STRATO.  All rights reserved.
+ * Copyright (C) 2011, 2012 STRATO.  All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public
@@ -25,6 +25,7 @@
 #include "transaction.h"
 #include "backref.h"
 #include "extent_io.h"
+#include "dev-replace.h"
 #include "check-integrity.h"
 #include "rcu-string.h"
 
@@ -42,10 +43,23 @@
  */
 
 struct scrub_block;
-struct scrub_dev;
+struct scrub_ctx;
 
-#define SCRUB_PAGES_PER_BIO     16      /* 64k per bio */
-#define SCRUB_BIOS_PER_DEV      16      /* 1 MB per device in flight */
+/*
+ * the following three values only influence the performance.
+ * The last one configures the number of parallel and outstanding I/O
+ * operations. The first two values configure an upper limit for the number
+ * of (dynamically allocated) pages that are added to a bio.
+ */
+#define SCRUB_PAGES_PER_RD_BIO  32      /* 128k per bio */
+#define SCRUB_PAGES_PER_WR_BIO  32      /* 128k per bio */
+#define SCRUB_BIOS_PER_SCTX     64      /* 8MB per device in flight */
+
+/*
+ * the following value times PAGE_SIZE needs to be large enough to match the
+ * largest node/leaf/sector size that shall be supported.
+ * Values larger than BTRFS_STRIPE_LEN are not supported.
+ */
 #define SCRUB_MAX_PAGES_PER_BLOCK       16      /* 64k per node/leaf/sector */
 
 struct scrub_page {
@@ -56,6 +70,8 @@ struct scrub_page {
         u64                     generation;
         u64                     logical;
         u64                     physical;
+        u64                     physical_for_dev_replace;
+        atomic_t                ref_count;
         struct {
                 unsigned int    mirror_num:8;
                 unsigned int    have_csum:1;
@@ -66,23 +82,28 @@ struct scrub_page {
 
 struct scrub_bio {
         int                     index;
-        struct scrub_dev        *sdev;
+        struct scrub_ctx        *sctx;
+        struct btrfs_device     *dev;
         struct bio              *bio;
         int                     err;
         u64                     logical;
         u64                     physical;
-        struct scrub_page       *pagev[SCRUB_PAGES_PER_BIO];
+#if SCRUB_PAGES_PER_WR_BIO >= SCRUB_PAGES_PER_RD_BIO
+        struct scrub_page       *pagev[SCRUB_PAGES_PER_WR_BIO];
+#else
+        struct scrub_page       *pagev[SCRUB_PAGES_PER_RD_BIO];
+#endif
         int                     page_count;
         int                     next_free;
         struct btrfs_work       work;
 };
 
 struct scrub_block {
-        struct scrub_page       pagev[SCRUB_MAX_PAGES_PER_BLOCK];
+        struct scrub_page       *pagev[SCRUB_MAX_PAGES_PER_BLOCK];
         int                     page_count;
         atomic_t                outstanding_pages;
         atomic_t                ref_count; /* free mem on transition to zero */
-        struct scrub_dev        *sdev;
+        struct scrub_ctx        *sctx;
         struct {
                 unsigned int    header_error:1;
                 unsigned int    checksum_error:1;
@@ -91,23 +112,35 @@ struct scrub_block {
         };
 };
 
-struct scrub_dev {
-        struct scrub_bio        *bios[SCRUB_BIOS_PER_DEV];
-        struct btrfs_device     *dev;
+struct scrub_wr_ctx {
+        struct scrub_bio *wr_curr_bio;
+        struct btrfs_device *tgtdev;
+        int pages_per_wr_bio; /* <= SCRUB_PAGES_PER_WR_BIO */
+        atomic_t flush_all_writes;
+        struct mutex wr_lock;
+};
+
+struct scrub_ctx {
+        struct scrub_bio        *bios[SCRUB_BIOS_PER_SCTX];
+        struct btrfs_root       *dev_root;
         int                     first_free;
         int                     curr;
-        atomic_t                in_flight;
-        atomic_t                fixup_cnt;
+        atomic_t                bios_in_flight;
+        atomic_t                workers_pending;
         spinlock_t              list_lock;
         wait_queue_head_t       list_wait;
         u16                     csum_size;
         struct list_head        csum_list;
         atomic_t                cancel_req;
         int                     readonly;
-        int                     pages_per_bio; /* <= SCRUB_PAGES_PER_BIO */
+        int                     pages_per_rd_bio;
         u32                     sectorsize;
         u32                     nodesize;
         u32                     leafsize;
+
+        int                     is_dev_replace;
+        struct scrub_wr_ctx     wr_ctx;
+
         /*
          * statistics
          */
@@ -116,13 +149,23 @@ struct scrub_dev {
 };
 
 struct scrub_fixup_nodatasum {
-        struct scrub_dev        *sdev;
+        struct scrub_ctx        *sctx;
+        struct btrfs_device     *dev;
         u64                     logical;
         struct btrfs_root       *root;
         struct btrfs_work       work;
         int                     mirror_num;
 };
 
+struct scrub_copy_nocow_ctx {
+        struct scrub_ctx        *sctx;
+        u64                     logical;
+        u64                     len;
+        int                     mirror_num;
+        u64                     physical_for_dev_replace;
+        struct btrfs_work       work;
+};
+
 struct scrub_warning {
         struct btrfs_path       *path;
         u64                     extent_item_size;
@@ -137,15 +180,20 @@ struct scrub_warning {
 };
 
 
+static void scrub_pending_bio_inc(struct scrub_ctx *sctx);
+static void scrub_pending_bio_dec(struct scrub_ctx *sctx);
+static void scrub_pending_trans_workers_inc(struct scrub_ctx *sctx);
+static void scrub_pending_trans_workers_dec(struct scrub_ctx *sctx);
 static int scrub_handle_errored_block(struct scrub_block *sblock_to_check);
-static int scrub_setup_recheck_block(struct scrub_dev *sdev,
-                                     struct btrfs_mapping_tree *map_tree,
+static int scrub_setup_recheck_block(struct scrub_ctx *sctx,
+                                     struct btrfs_fs_info *fs_info,
+                                     struct scrub_block *original_sblock,
                                      u64 length, u64 logical,
-                                     struct scrub_block *sblock);
-static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
-                               struct scrub_block *sblock, int is_metadata,
-                               int have_csum, u8 *csum, u64 generation,
-                               u16 csum_size);
+                                     struct scrub_block *sblocks_for_recheck);
+static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
+                                struct scrub_block *sblock, int is_metadata,
+                                int have_csum, u8 *csum, u64 generation,
+                                u16 csum_size);
 static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
                                          struct scrub_block *sblock,
                                          int is_metadata, int have_csum,
@@ -158,118 +206,221 @@ static int scrub_repair_block_from_good_copy(struct scrub_block *sblock_bad,
 static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                                             struct scrub_block *sblock_good,
                                             int page_num, int force_write);
+static void scrub_write_block_to_dev_replace(struct scrub_block *sblock);
+static int scrub_write_page_to_dev_replace(struct scrub_block *sblock,
+                                           int page_num);
 static int scrub_checksum_data(struct scrub_block *sblock);
 static int scrub_checksum_tree_block(struct scrub_block *sblock);
 static int scrub_checksum_super(struct scrub_block *sblock);
 static void scrub_block_get(struct scrub_block *sblock);
 static void scrub_block_put(struct scrub_block *sblock);
-static int scrub_add_page_to_bio(struct scrub_dev *sdev,
-                                 struct scrub_page *spage);
-static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len,
-                       u64 physical, u64 flags, u64 gen, int mirror_num,
-                       u8 *csum, int force);
+static void scrub_page_get(struct scrub_page *spage);
+static void scrub_page_put(struct scrub_page *spage);
+static int scrub_add_page_to_rd_bio(struct scrub_ctx *sctx,
+                                    struct scrub_page *spage);
+static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
+                       u64 physical, struct btrfs_device *dev, u64 flags,
+                       u64 gen, int mirror_num, u8 *csum, int force,
+                       u64 physical_for_dev_replace);
 static void scrub_bio_end_io(struct bio *bio, int err);
 static void scrub_bio_end_io_worker(struct btrfs_work *work);
 static void scrub_block_complete(struct scrub_block *sblock);
+static void scrub_remap_extent(struct btrfs_fs_info *fs_info,
+                               u64 extent_logical, u64 extent_len,
+                               u64 *extent_physical,
+                               struct btrfs_device **extent_dev,
+                               int *extent_mirror_num);
+static int scrub_setup_wr_ctx(struct scrub_ctx *sctx,
+                              struct scrub_wr_ctx *wr_ctx,
+                              struct btrfs_fs_info *fs_info,
+                              struct btrfs_device *dev,
+                              int is_dev_replace);
+static void scrub_free_wr_ctx(struct scrub_wr_ctx *wr_ctx);
+static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,
+                                    struct scrub_page *spage);
+static void scrub_wr_submit(struct scrub_ctx *sctx);
+static void scrub_wr_bio_end_io(struct bio *bio, int err);
+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);
+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);
+
+
+static void scrub_pending_bio_inc(struct scrub_ctx *sctx)
+{
+        atomic_inc(&sctx->bios_in_flight);
+}
 
+static void scrub_pending_bio_dec(struct scrub_ctx *sctx)
+{
+        atomic_dec(&sctx->bios_in_flight);
+        wake_up(&sctx->list_wait);
+}
 
-static void scrub_free_csums(struct scrub_dev *sdev)
+/*
+ * used for workers that require transaction commits (i.e., for the
+ * NOCOW case)
+ */
+static void scrub_pending_trans_workers_inc(struct scrub_ctx *sctx)
 {
-        while (!list_empty(&sdev->csum_list)) {
+        struct btrfs_fs_info *fs_info = sctx->dev_root->fs_info;
+
+        /*
+         * increment scrubs_running to prevent cancel requests from
+         * completing as long as a worker is running. we must also
+         * increment scrubs_paused to prevent deadlocking on pause
+         * requests used for transactions commits (as the worker uses a
+         * transaction context). it is safe to regard the worker
+         * as paused for all matters practical. effectively, we only
+         * avoid cancellation requests from completing.
+         */
+        mutex_lock(&fs_info->scrub_lock);
+        atomic_inc(&fs_info->scrubs_running);
+        atomic_inc(&fs_info->scrubs_paused);
+        mutex_unlock(&fs_info->scrub_lock);
+        atomic_inc(&sctx->workers_pending);
+}
+
+/* used for workers that require transaction commits */
+static void scrub_pending_trans_workers_dec(struct scrub_ctx *sctx)
+{
+        struct btrfs_fs_info *fs_info = sctx->dev_root->fs_info;
+
+        /*
+         * see scrub_pending_trans_workers_inc() why we're pretending
+         * to be paused in the scrub counters
+         */
+        mutex_lock(&fs_info->scrub_lock);
+        atomic_dec(&fs_info->scrubs_running);
+        atomic_dec(&fs_info->scrubs_paused);
+        mutex_unlock(&fs_info->scrub_lock);
+        atomic_dec(&sctx->workers_pending);
+        wake_up(&fs_info->scrub_pause_wait);
+        wake_up(&sctx->list_wait);
+}
+
+static void scrub_free_csums(struct scrub_ctx *sctx)
+{
+        while (!list_empty(&sctx->csum_list)) {
                 struct btrfs_ordered_sum *sum;
-                sum = list_first_entry(&sdev->csum_list,
+                sum = list_first_entry(&sctx->csum_list,
                                        struct btrfs_ordered_sum, list);
                 list_del(&sum->list);
                 kfree(sum);
         }
 }
 
-static noinline_for_stack void scrub_free_dev(struct scrub_dev *sdev)
+static noinline_for_stack void scrub_free_ctx(struct scrub_ctx *sctx)
 {
         int i;
 
-        if (!sdev)
+        if (!sctx)
                 return;
 
+        scrub_free_wr_ctx(&sctx->wr_ctx);
+
         /* this can happen when scrub is cancelled */
-        if (sdev->curr != -1) {
-                struct scrub_bio *sbio = sdev->bios[sdev->curr];
+        if (sctx->curr != -1) {
+                struct scrub_bio *sbio = sctx->bios[sctx->curr];
 
                 for (i = 0; i < sbio->page_count; i++) {
-                        BUG_ON(!sbio->pagev[i]);
-                        BUG_ON(!sbio->pagev[i]->page);
+                        WARN_ON(!sbio->pagev[i]->page);
                         scrub_block_put(sbio->pagev[i]->sblock);
                 }
                 bio_put(sbio->bio);
         }
 
-        for (i = 0; i < SCRUB_BIOS_PER_DEV; ++i) {
-                struct scrub_bio *sbio = sdev->bios[i];
+        for (i = 0; i < SCRUB_BIOS_PER_SCTX; ++i) {
+                struct scrub_bio *sbio = sctx->bios[i];
 
                 if (!sbio)
                         break;
                 kfree(sbio);
         }
 
-        scrub_free_csums(sdev);
-        kfree(sdev);
+        scrub_free_csums(sctx);
+        kfree(sctx);
 }
 
 static noinline_for_stack
-struct scrub_dev *scrub_setup_dev(struct btrfs_device *dev)
+struct scrub_ctx *scrub_setup_ctx(struct btrfs_device *dev, int is_dev_replace)
 {
-        struct scrub_dev *sdev;
+        struct scrub_ctx *sctx;
         int             i;
         struct btrfs_fs_info *fs_info = dev->dev_root->fs_info;
-        int pages_per_bio;
+        int pages_per_rd_bio;
+        int ret;
 
-        pages_per_bio = min_t(int, SCRUB_PAGES_PER_BIO,
-                              bio_get_nr_vecs(dev->bdev));
-        sdev = kzalloc(sizeof(*sdev), GFP_NOFS);
-        if (!sdev)
+        /*
+         * the setting of pages_per_rd_bio is correct for scrub but might
+         * be wrong for the dev_replace code where we might read from
+         * different devices in the initial huge bios. However, that
+         * code is able to correctly handle the case when adding a page
+         * to a bio fails.
+         */
+        if (dev->bdev)
+                pages_per_rd_bio = min_t(int, SCRUB_PAGES_PER_RD_BIO,
+                                         bio_get_nr_vecs(dev->bdev));
+        else
+                pages_per_rd_bio = SCRUB_PAGES_PER_RD_BIO;
+        sctx = kzalloc(sizeof(*sctx), GFP_NOFS);
+        if (!sctx)
                 goto nomem;
-        sdev->dev = dev;
-        sdev->pages_per_bio = pages_per_bio;
-        sdev->curr = -1;
-        for (i = 0; i < SCRUB_BIOS_PER_DEV; ++i) {
+        sctx->is_dev_replace = is_dev_replace;
+        sctx->pages_per_rd_bio = pages_per_rd_bio;
+        sctx->curr = -1;
+        sctx->dev_root = dev->dev_root;
+        for (i = 0; i < SCRUB_BIOS_PER_SCTX; ++i) {
                 struct scrub_bio *sbio;
 
                 sbio = kzalloc(sizeof(*sbio), GFP_NOFS);
                 if (!sbio)
                         goto nomem;
-                sdev->bios[i] = sbio;
+                sctx->bios[i] = sbio;
 
                 sbio->index = i;
-                sbio->sdev = sdev;
+                sbio->sctx = sctx;
                 sbio->page_count = 0;
                 sbio->work.func = scrub_bio_end_io_worker;
 
-                if (i != SCRUB_BIOS_PER_DEV-1)
-                        sdev->bios[i]->next_free = i + 1;
+                if (i != SCRUB_BIOS_PER_SCTX - 1)
+                        sctx->bios[i]->next_free = i + 1;
                 else
-                        sdev->bios[i]->next_free = -1;
-        }
-        sdev->first_free = 0;
-        sdev->nodesize = dev->dev_root->nodesize;
-        sdev->leafsize = dev->dev_root->leafsize;
-        sdev->sectorsize = dev->dev_root->sectorsize;
-        atomic_set(&sdev->in_flight, 0);
-        atomic_set(&sdev->fixup_cnt, 0);
-        atomic_set(&sdev->cancel_req, 0);
-        sdev->csum_size = btrfs_super_csum_size(fs_info->super_copy);
-        INIT_LIST_HEAD(&sdev->csum_list);
-
-        spin_lock_init(&sdev->list_lock);
-        spin_lock_init(&sdev->stat_lock);
-        init_waitqueue_head(&sdev->list_wait);
-        return sdev;
+                        sctx->bios[i]->next_free = -1;
+        }
+        sctx->first_free = 0;
+        sctx->nodesize = dev->dev_root->nodesize;
+        sctx->leafsize = dev->dev_root->leafsize;
+        sctx->sectorsize = dev->dev_root->sectorsize;
+        atomic_set(&sctx->bios_in_flight, 0);
+        atomic_set(&sctx->workers_pending, 0);
+        atomic_set(&sctx->cancel_req, 0);
+        sctx->csum_size = btrfs_super_csum_size(fs_info->super_copy);
+        INIT_LIST_HEAD(&sctx->csum_list);
+
+        spin_lock_init(&sctx->list_lock);
+        spin_lock_init(&sctx->stat_lock);
+        init_waitqueue_head(&sctx->list_wait);
+
+        ret = scrub_setup_wr_ctx(sctx, &sctx->wr_ctx, fs_info,
+                                 fs_info->dev_replace.tgtdev, is_dev_replace);
+        if (ret) {
+                scrub_free_ctx(sctx);
+                return ERR_PTR(ret);
+        }
+        return sctx;
 
 nomem:
-        scrub_free_dev(sdev);
+        scrub_free_ctx(sctx);
         return ERR_PTR(-ENOMEM);
 }
 
-static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, void *ctx)
+static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
+                                     void *warn_ctx)
 {
         u64 isize;
         u32 nlink;
@@ -277,7 +428,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, void *ctx)
         int i;
         struct extent_buffer *eb;
         struct btrfs_inode_item *inode_item;
-        struct scrub_warning *swarn = ctx;
+        struct scrub_warning *swarn = warn_ctx;
         struct btrfs_fs_info *fs_info = swarn->dev->dev_root->fs_info;
         struct inode_fs_paths *ipath = NULL;
         struct btrfs_root *local_root;
@@ -345,37 +496,42 @@ err:
 
 static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
 {
-        struct btrfs_device *dev = sblock->sdev->dev;
-        struct btrfs_fs_info *fs_info = dev->dev_root->fs_info;
+        struct btrfs_device *dev;
+        struct btrfs_fs_info *fs_info;
         struct btrfs_path *path;
         struct btrfs_key found_key;
         struct extent_buffer *eb;
         struct btrfs_extent_item *ei;
         struct scrub_warning swarn;
-        u32 item_size;
-        int ret;
+        unsigned long ptr = 0;
+        u64 extent_item_pos;
+        u64 flags = 0;
         u64 ref_root;
+        u32 item_size;
         u8 ref_level;
-        unsigned long ptr = 0;
         const int bufsize = 4096;
-        u64 extent_item_pos;
+        int ret;
+
+        WARN_ON(sblock->page_count < 1);
+        dev = sblock->pagev[0]->dev;
+        fs_info = sblock->sctx->dev_root->fs_info;
 
         path = btrfs_alloc_path();
 
         swarn.scratch_buf = kmalloc(bufsize, GFP_NOFS);
         swarn.msg_buf = kmalloc(bufsize, GFP_NOFS);
-        BUG_ON(sblock->page_count < 1);
-        swarn.sector = (sblock->pagev[0].physical) >> 9;
-        swarn.logical = sblock->pagev[0].logical;
+        swarn.sector = (sblock->pagev[0]->physical) >> 9;
+        swarn.logical = sblock->pagev[0]->logical;
         swarn.errstr = errstr;
-        swarn.dev = dev;
+        swarn.dev = NULL;
         swarn.msg_bufsize = bufsize;
         swarn.scratch_bufsize = bufsize;
 
         if (!path || !swarn.scratch_buf || !swarn.msg_buf)
                 goto out;
 
-        ret = extent_from_logical(fs_info, swarn.logical, path, &found_key);
+        ret = extent_from_logical(fs_info, swarn.logical, path, &found_key,
+                                  &flags);
         if (ret < 0)
                 goto out;
 
@@ -387,7 +543,7 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
         item_size = btrfs_item_size_nr(eb, path->slots[0]);
         btrfs_release_path(path);
 
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
                 do {
                         ret = tree_backref_for_extent(&ptr, eb, ei, item_size,
                                                         &ref_root, &ref_level);
@@ -403,6 +559,7 @@ static void scrub_print_warning(const char *errstr, struct scrub_block *sblock)
                 } while (ret != 1);
         } else {
                 swarn.path = path;
+                swarn.dev = dev;
                 iterate_extent_inodes(fs_info, found_key.objectid,
                                         extent_item_pos, 1,
                                         scrub_print_warning_inode, &swarn);
@@ -414,11 +571,11 @@ out:
         kfree(swarn.msg_buf);
 }
 
-static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx)
+static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *fixup_ctx)
 {
         struct page *page = NULL;
         unsigned long index;
-        struct scrub_fixup_nodatasum *fixup = ctx;
+        struct scrub_fixup_nodatasum *fixup = fixup_ctx;
         int ret;
         int corrected = 0;
         struct btrfs_key key;
@@ -449,7 +606,7 @@ static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx)
         }
 
         if (PageUptodate(page)) {
-                struct btrfs_mapping_tree *map_tree;
+                struct btrfs_fs_info *fs_info;
                 if (PageDirty(page)) {
                         /*
                          * we need to write the data to the defect sector. the
@@ -470,8 +627,8 @@ static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx)
                         ret = -EIO;
                         goto out;
                 }
-                map_tree = &BTRFS_I(inode)->root->fs_info->mapping_tree;
-                ret = repair_io_failure(map_tree, offset, PAGE_SIZE,
+                fs_info = BTRFS_I(inode)->root->fs_info;
+                ret = repair_io_failure(fs_info, offset, PAGE_SIZE,
                                         fixup->logical, page,
                                         fixup->mirror_num);
                 unlock_page(page);
@@ -528,21 +685,21 @@ static void scrub_fixup_nodatasum(struct btrfs_work *work)
 {
         int ret;
         struct scrub_fixup_nodatasum *fixup;
-        struct scrub_dev *sdev;
+        struct scrub_ctx *sctx;
         struct btrfs_trans_handle *trans = NULL;
         struct btrfs_fs_info *fs_info;
         struct btrfs_path *path;
         int uncorrectable = 0;
 
         fixup = container_of(work, struct scrub_fixup_nodatasum, work);
-        sdev = fixup->sdev;
+        sctx = fixup->sctx;
         fs_info = fixup->root->fs_info;
 
         path = btrfs_alloc_path();
         if (!path) {
-                spin_lock(&sdev->stat_lock);
-                ++sdev->stat.malloc_errors;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                ++sctx->stat.malloc_errors;
+                spin_unlock(&sctx->stat_lock);
                 uncorrectable = 1;
                 goto out;
         }
@@ -571,35 +728,30 @@ static void scrub_fixup_nodatasum(struct btrfs_work *work)
         }
         WARN_ON(ret != 1);
 
-        spin_lock(&sdev->stat_lock);
-        ++sdev->stat.corrected_errors;
-        spin_unlock(&sdev->stat_lock);
+        spin_lock(&sctx->stat_lock);
+        ++sctx->stat.corrected_errors;
+        spin_unlock(&sctx->stat_lock);
 
 out:
         if (trans && !IS_ERR(trans))
                 btrfs_end_transaction(trans, fixup->root);
         if (uncorrectable) {
-                spin_lock(&sdev->stat_lock);
-                ++sdev->stat.uncorrectable_errors;
-                spin_unlock(&sdev->stat_lock);
-
+                spin_lock(&sctx->stat_lock);
+                ++sctx->stat.uncorrectable_errors;
+                spin_unlock(&sctx->stat_lock);
+                btrfs_dev_replace_stats_inc(
+                        &sctx->dev_root->fs_info->dev_replace.
+                        num_uncorrectable_read_errors);
                 printk_ratelimited_in_rcu(KERN_ERR
                         "btrfs: unable to fixup (nodatasum) error at logical %llu on dev %s\n",
                         (unsigned long long)fixup->logical,
-                        rcu_str_deref(sdev->dev->name));
+                        rcu_str_deref(fixup->dev->name));
         }
 
         btrfs_free_path(path);
         kfree(fixup);
 
-        /* see caller why we're pretending to be paused in the scrub counters */
-        mutex_lock(&fs_info->scrub_lock);
-        atomic_dec(&fs_info->scrubs_running);
-        atomic_dec(&fs_info->scrubs_paused);
-        mutex_unlock(&fs_info->scrub_lock);
-        atomic_dec(&sdev->fixup_cnt);
-        wake_up(&fs_info->scrub_pause_wait);
-        wake_up(&sdev->list_wait);
+        scrub_pending_trans_workers_dec(sctx);
 }
 
 /*
@@ -612,7 +764,8 @@ out:
  */
 static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
 {
-        struct scrub_dev *sdev = sblock_to_check->sdev;
+        struct scrub_ctx *sctx = sblock_to_check->sctx;
+        struct btrfs_device *dev;
         struct btrfs_fs_info *fs_info;
         u64 length;
         u64 logical;
@@ -631,16 +784,33 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                                       DEFAULT_RATELIMIT_BURST);
 
         BUG_ON(sblock_to_check->page_count < 1);
-        fs_info = sdev->dev->dev_root->fs_info;
+        fs_info = sctx->dev_root->fs_info;
+        if (sblock_to_check->pagev[0]->flags & BTRFS_EXTENT_FLAG_SUPER) {
+                /*
+                 * if we find an error in a super block, we just report it.
+                 * They will get written with the next transaction commit
+                 * anyway
+                 */
+                spin_lock(&sctx->stat_lock);
+                ++sctx->stat.super_errors;
+                spin_unlock(&sctx->stat_lock);
+                return 0;
+        }
         length = sblock_to_check->page_count * PAGE_SIZE;
-        logical = sblock_to_check->pagev[0].logical;
-        generation = sblock_to_check->pagev[0].generation;
-        BUG_ON(sblock_to_check->pagev[0].mirror_num < 1);
-        failed_mirror_index = sblock_to_check->pagev[0].mirror_num - 1;
-        is_metadata = !(sblock_to_check->pagev[0].flags &
+        logical = sblock_to_check->pagev[0]->logical;
+        generation = sblock_to_check->pagev[0]->generation;
+        BUG_ON(sblock_to_check->pagev[0]->mirror_num < 1);
+        failed_mirror_index = sblock_to_check->pagev[0]->mirror_num - 1;
+        is_metadata = !(sblock_to_check->pagev[0]->flags &
                         BTRFS_EXTENT_FLAG_DATA);
-        have_csum = sblock_to_check->pagev[0].have_csum;
-        csum = sblock_to_check->pagev[0].csum;
+        have_csum = sblock_to_check->pagev[0]->have_csum;
+        csum = sblock_to_check->pagev[0]->csum;
+        dev = sblock_to_check->pagev[0]->dev;
+
+        if (sctx->is_dev_replace && !is_metadata && !have_csum) {
+                sblocks_for_recheck = NULL;
+                goto nodatasum_case;
+        }
 
         /*
          * read all mirrors one after the other. This includes to
@@ -675,43 +845,32 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                                      sizeof(*sblocks_for_recheck),
                                      GFP_NOFS);
         if (!sblocks_for_recheck) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.malloc_errors++;
-                sdev->stat.read_errors++;
-                sdev->stat.uncorrectable_errors++;
-                spin_unlock(&sdev->stat_lock);
-                btrfs_dev_stat_inc_and_print(sdev->dev,
-                                             BTRFS_DEV_STAT_READ_ERRS);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.malloc_errors++;
+                sctx->stat.read_errors++;
+                sctx->stat.uncorrectable_errors++;
+                spin_unlock(&sctx->stat_lock);
+                btrfs_dev_stat_inc_and_print(dev, BTRFS_DEV_STAT_READ_ERRS);
                 goto out;
         }
 
         /* setup the context, map the logical blocks and alloc the pages */
-        ret = scrub_setup_recheck_block(sdev, &fs_info->mapping_tree, length,
+        ret = scrub_setup_recheck_block(sctx, fs_info, sblock_to_check, length,
                                         logical, sblocks_for_recheck);
         if (ret) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.read_errors++;
-                sdev->stat.uncorrectable_errors++;
-                spin_unlock(&sdev->stat_lock);
-                btrfs_dev_stat_inc_and_print(sdev->dev,
-                                             BTRFS_DEV_STAT_READ_ERRS);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.read_errors++;
+                sctx->stat.uncorrectable_errors++;
+                spin_unlock(&sctx->stat_lock);
+                btrfs_dev_stat_inc_and_print(dev, BTRFS_DEV_STAT_READ_ERRS);
                 goto out;
         }
         BUG_ON(failed_mirror_index >= BTRFS_MAX_MIRRORS);
         sblock_bad = sblocks_for_recheck + failed_mirror_index;
 
         /* build and submit the bios for the failed mirror, check checksums */
-        ret = scrub_recheck_block(fs_info, sblock_bad, is_metadata, have_csum,
-                                  csum, generation, sdev->csum_size);
-        if (ret) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.read_errors++;
-                sdev->stat.uncorrectable_errors++;
-                spin_unlock(&sdev->stat_lock);
-                btrfs_dev_stat_inc_and_print(sdev->dev,
-                                             BTRFS_DEV_STAT_READ_ERRS);
-                goto out;
-        }
+        scrub_recheck_block(fs_info, sblock_bad, is_metadata, have_csum,
+                            csum, generation, sctx->csum_size);
 
         if (!sblock_bad->header_error && !sblock_bad->checksum_error &&
             sblock_bad->no_io_error_seen) {
@@ -723,50 +882,54 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                  * different bio (usually one of the two latter cases is
                  * the cause)
                  */
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.unverified_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.unverified_errors++;
+                spin_unlock(&sctx->stat_lock);
 
+                if (sctx->is_dev_replace)
+                        scrub_write_block_to_dev_replace(sblock_bad);
                 goto out;
         }
 
         if (!sblock_bad->no_io_error_seen) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.read_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.read_errors++;
+                spin_unlock(&sctx->stat_lock);
                 if (__ratelimit(&_rs))
                         scrub_print_warning("i/o error", sblock_to_check);
-                btrfs_dev_stat_inc_and_print(sdev->dev,
-                                             BTRFS_DEV_STAT_READ_ERRS);
+                btrfs_dev_stat_inc_and_print(dev, BTRFS_DEV_STAT_READ_ERRS);
         } else if (sblock_bad->checksum_error) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.csum_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.csum_errors++;
+                spin_unlock(&sctx->stat_lock);
                 if (__ratelimit(&_rs))
                         scrub_print_warning("checksum error", sblock_to_check);
-                btrfs_dev_stat_inc_and_print(sdev->dev,
+                btrfs_dev_stat_inc_and_print(dev,
                                              BTRFS_DEV_STAT_CORRUPTION_ERRS);
         } else if (sblock_bad->header_error) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.verify_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.verify_errors++;
+                spin_unlock(&sctx->stat_lock);
                 if (__ratelimit(&_rs))
                         scrub_print_warning("checksum/header error",
                                             sblock_to_check);
                 if (sblock_bad->generation_error)
-                        btrfs_dev_stat_inc_and_print(sdev->dev,
+                        btrfs_dev_stat_inc_and_print(dev,
                                 BTRFS_DEV_STAT_GENERATION_ERRS);
                 else
-                        btrfs_dev_stat_inc_and_print(sdev->dev,
+                        btrfs_dev_stat_inc_and_print(dev,
                                 BTRFS_DEV_STAT_CORRUPTION_ERRS);
         }
 
-        if (sdev->readonly)
+        if (sctx->readonly && !sctx->is_dev_replace)
                 goto did_not_correct_error;
 
         if (!is_metadata && !have_csum) {
                 struct scrub_fixup_nodatasum *fixup_nodatasum;
 
+nodatasum_case:
+                WARN_ON(sctx->is_dev_replace);
+
                 /*
                  * !is_metadata and !have_csum, this means that the data
                  * might not be COW'ed, that it might be modified
@@ -777,24 +940,12 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                 fixup_nodatasum = kzalloc(sizeof(*fixup_nodatasum), GFP_NOFS);
                 if (!fixup_nodatasum)
                         goto did_not_correct_error;
-                fixup_nodatasum->sdev = sdev;
+                fixup_nodatasum->sctx = sctx;
+                fixup_nodatasum->dev = dev;
                 fixup_nodatasum->logical = logical;
                 fixup_nodatasum->root = fs_info->extent_root;
                 fixup_nodatasum->mirror_num = failed_mirror_index + 1;
-                /*
-                 * increment scrubs_running to prevent cancel requests from
-                 * completing as long as a fixup worker is running. we must also
-                 * increment scrubs_paused to prevent deadlocking on pause
-                 * requests used for transactions commits (as the worker uses a
-                 * transaction context). it is safe to regard the fixup worker
-                 * as paused for all matters practical. effectively, we only
-                 * avoid cancellation requests from completing.
-                 */
-                mutex_lock(&fs_info->scrub_lock);
-                atomic_inc(&fs_info->scrubs_running);
-                atomic_inc(&fs_info->scrubs_paused);
-                mutex_unlock(&fs_info->scrub_lock);
-                atomic_inc(&sdev->fixup_cnt);
+                scrub_pending_trans_workers_inc(sctx);
                 fixup_nodatasum->work.func = scrub_fixup_nodatasum;
                 btrfs_queue_worker(&fs_info->scrub_workers,
                                    &fixup_nodatasum->work);
@@ -803,26 +954,8 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
 
         /*
          * now build and submit the bios for the other mirrors, check
-         * checksums
-         */
-        for (mirror_index = 0;
-             mirror_index < BTRFS_MAX_MIRRORS &&
-             sblocks_for_recheck[mirror_index].page_count > 0;
-             mirror_index++) {
-                if (mirror_index == failed_mirror_index)
-                        continue;
-
-                /* build and submit the bios, check checksums */
-                ret = scrub_recheck_block(fs_info,
-                                          sblocks_for_recheck + mirror_index,
-                                          is_metadata, have_csum, csum,
-                                          generation, sdev->csum_size);
-                if (ret)
-                        goto did_not_correct_error;
-        }
-
-        /*
-         * first try to pick the mirror which is completely without I/O
+         * checksums.
+         * First try to pick the mirror which is completely without I/O
          * errors and also does not have a checksum error.
          * If one is found, and if a checksum is present, the full block
          * that is known to contain an error is rewritten. Afterwards
@@ -838,24 +971,93 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
              mirror_index < BTRFS_MAX_MIRRORS &&
              sblocks_for_recheck[mirror_index].page_count > 0;
              mirror_index++) {
-                struct scrub_block *sblock_other = sblocks_for_recheck +
-                                                   mirror_index;
+                struct scrub_block *sblock_other;
+
+                if (mirror_index == failed_mirror_index)
+                        continue;
+                sblock_other = sblocks_for_recheck + mirror_index;
+
+                /* build and submit the bios, check checksums */
+                scrub_recheck_block(fs_info, sblock_other, is_metadata,
+                                    have_csum, csum, generation,
+                                    sctx->csum_size);
 
                 if (!sblock_other->header_error &&
                     !sblock_other->checksum_error &&
                     sblock_other->no_io_error_seen) {
-                        int force_write = is_metadata || have_csum;
-
-                        ret = scrub_repair_block_from_good_copy(sblock_bad,
-                                                                sblock_other,
-                                                                force_write);
+                        if (sctx->is_dev_replace) {
+                                scrub_write_block_to_dev_replace(sblock_other);
+                        } else {
+                                int force_write = is_metadata || have_csum;
+
+                                ret = scrub_repair_block_from_good_copy(
+                                                sblock_bad, sblock_other,
+                                                force_write);
+                        }
                         if (0 == ret)
                                 goto corrected_error;
                 }
         }
 
         /*
-         * in case of I/O errors in the area that is supposed to be
+         * for dev_replace, pick good pages and write to the target device.
+         */
+        if (sctx->is_dev_replace) {
+                success = 1;
+                for (page_num = 0; page_num < sblock_bad->page_count;
+                     page_num++) {
+                        int sub_success;
+
+                        sub_success = 0;
+                        for (mirror_index = 0;
+                             mirror_index < BTRFS_MAX_MIRRORS &&
+                             sblocks_for_recheck[mirror_index].page_count > 0;
+                             mirror_index++) {
+                                struct scrub_block *sblock_other =
+                                        sblocks_for_recheck + mirror_index;
+                                struct scrub_page *page_other =
+                                        sblock_other->pagev[page_num];
+
+                                if (!page_other->io_error) {
+                                        ret = scrub_write_page_to_dev_replace(
+                                                        sblock_other, page_num);
+                                        if (ret == 0) {
+                                                /* succeeded for this page */
+                                                sub_success = 1;
+                                                break;
+                                        } else {
+                                                btrfs_dev_replace_stats_inc(
+                                                        &sctx->dev_root->
+                                                        fs_info->dev_replace.
+                                                        num_write_errors);
+                                        }
+                                }
+                        }
+
+                        if (!sub_success) {
+                                /*
+                                 * did not find a mirror to fetch the page
+                                 * from. scrub_write_page_to_dev_replace()
+                                 * handles this case (page->io_error), by
+                                 * filling the block with zeros before
+                                 * submitting the write request
+                                 */
+                                success = 0;
+                                ret = scrub_write_page_to_dev_replace(
+                                                sblock_bad, page_num);
+                                if (ret)
+                                        btrfs_dev_replace_stats_inc(
+                                                &sctx->dev_root->fs_info->
+                                                dev_replace.num_write_errors);
+                        }
+                }
+
+                goto out;
+        }
+
+        /*
+         * for regular scrub, repair those pages that are errored.
+         * In case of I/O errors in the area that is supposed to be
          * repaired, continue by picking good copies of those pages.
          * Select the good pages from mirrors to rewrite bad pages from
          * the area to fix. Afterwards verify the checksum of the block
@@ -885,7 +1087,7 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
 
         success = 1;
         for (page_num = 0; page_num < sblock_bad->page_count; page_num++) {
-                struct scrub_page *page_bad = sblock_bad->pagev + page_num;
+                struct scrub_page *page_bad = sblock_bad->pagev[page_num];
 
                 if (!page_bad->io_error)
                         continue;
@@ -896,8 +1098,8 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                      mirror_index++) {
                         struct scrub_block *sblock_other = sblocks_for_recheck +
                                                            mirror_index;
-                        struct scrub_page *page_other = sblock_other->pagev +
-                                                        page_num;
+                        struct scrub_page *page_other = sblock_other->pagev[
+                                                        page_num];
 
                         if (!page_other->io_error) {
                                 ret = scrub_repair_page_from_good_copy(
@@ -926,10 +1128,10 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                          * is verified, but most likely the data comes out
                          * of the page cache.
                          */
-                        ret = scrub_recheck_block(fs_info, sblock_bad,
-                                                  is_metadata, have_csum, csum,
-                                                  generation, sdev->csum_size);
-                        if (!ret && !sblock_bad->header_error &&
+                        scrub_recheck_block(fs_info, sblock_bad,
+                                            is_metadata, have_csum, csum,
+                                            generation, sctx->csum_size);
+                        if (!sblock_bad->header_error &&
                             !sblock_bad->checksum_error &&
                             sblock_bad->no_io_error_seen)
                                 goto corrected_error;
@@ -937,23 +1139,23 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                                 goto did_not_correct_error;
                 } else {
 corrected_error:
-                        spin_lock(&sdev->stat_lock);
-                        sdev->stat.corrected_errors++;
-                        spin_unlock(&sdev->stat_lock);
+                        spin_lock(&sctx->stat_lock);
+                        sctx->stat.corrected_errors++;
+                        spin_unlock(&sctx->stat_lock);
                         printk_ratelimited_in_rcu(KERN_ERR
                                 "btrfs: fixed up error at logical %llu on dev %s\n",
                                 (unsigned long long)logical,
-                                rcu_str_deref(sdev->dev->name));
+                                rcu_str_deref(dev->name));
                 }
         } else {
 did_not_correct_error:
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.uncorrectable_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.uncorrectable_errors++;
+                spin_unlock(&sctx->stat_lock);
                 printk_ratelimited_in_rcu(KERN_ERR
                         "btrfs: unable to fixup (regular) error at logical %llu on dev %s\n",
                         (unsigned long long)logical,
-                        rcu_str_deref(sdev->dev->name));
+                        rcu_str_deref(dev->name));
         }
 
 out:
@@ -964,11 +1166,11 @@ out:
                                                      mirror_index;
                         int page_index;
 
-                        for (page_index = 0; page_index < SCRUB_PAGES_PER_BIO;
-                             page_index++)
-                                if (sblock->pagev[page_index].page)
-                                        __free_page(
-                                                sblock->pagev[page_index].page);
+                        for (page_index = 0; page_index < sblock->page_count;
+                             page_index++) {
+                                sblock->pagev[page_index]->sblock = NULL;
+                                scrub_page_put(sblock->pagev[page_index]);
+                        }
                 }
                 kfree(sblocks_for_recheck);
         }
@@ -976,8 +1178,9 @@ out:
         return 0;
 }
 
-static int scrub_setup_recheck_block(struct scrub_dev *sdev,
-                                     struct btrfs_mapping_tree *map_tree,
+static int scrub_setup_recheck_block(struct scrub_ctx *sctx,
+                                     struct btrfs_fs_info *fs_info,
+                                     struct scrub_block *original_sblock,
                                      u64 length, u64 logical,
                                      struct scrub_block *sblocks_for_recheck)
 {
@@ -986,7 +1189,7 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
         int ret;
 
         /*
-         * note: the three members sdev, ref_count and outstanding_pages
+         * note: the two members ref_count and outstanding_pages
          * are not used (and not set) in the blocks that are used for
          * the recheck procedure
          */
@@ -1001,14 +1204,14 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
                  * with a length of PAGE_SIZE, each returned stripe
                  * represents one mirror
                  */
-                ret = btrfs_map_block(map_tree, WRITE, logical, &mapped_length,
-                                      &bbio, 0);
+                ret = btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS, logical,
+                                      &mapped_length, &bbio, 0);
                 if (ret || !bbio || mapped_length < sublen) {
                         kfree(bbio);
                         return -EIO;
                 }
 
-                BUG_ON(page_index >= SCRUB_PAGES_PER_BIO);
+                BUG_ON(page_index >= SCRUB_PAGES_PER_RD_BIO);
                 for (mirror_index = 0; mirror_index < (int)bbio->num_stripes;
                      mirror_index++) {
                         struct scrub_block *sblock;
@@ -1018,20 +1221,31 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
                                 continue;
 
                         sblock = sblocks_for_recheck + mirror_index;
-                        page = sblock->pagev + page_index;
+                        sblock->sctx = sctx;
+                        page = kzalloc(sizeof(*page), GFP_NOFS);
+                        if (!page) {
+leave_nomem:
+                                spin_lock(&sctx->stat_lock);
+                                sctx->stat.malloc_errors++;
+                                spin_unlock(&sctx->stat_lock);
+                                kfree(bbio);
+                                return -ENOMEM;
+                        }
+                        scrub_page_get(page);
+                        sblock->pagev[page_index] = page;
                         page->logical = logical;
                         page->physical = bbio->stripes[mirror_index].physical;
+                        BUG_ON(page_index >= original_sblock->page_count);
+                        page->physical_for_dev_replace =
+                                original_sblock->pagev[page_index]->
+                                physical_for_dev_replace;
                         /* for missing devices, dev->bdev is NULL */
                         page->dev = bbio->stripes[mirror_index].dev;
                         page->mirror_num = mirror_index + 1;
-                        page->page = alloc_page(GFP_NOFS);
-                        if (!page->page) {
-                                spin_lock(&sdev->stat_lock);
-                                sdev->stat.malloc_errors++;
-                                spin_unlock(&sdev->stat_lock);
-                                return -ENOMEM;
-                        }
                         sblock->page_count++;
+                        page->page = alloc_page(GFP_NOFS);
+                        if (!page->page)
+                                goto leave_nomem;
                 }
                 kfree(bbio);
                 length -= sublen;
@@ -1049,10 +1263,10 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
  * to take those pages that are not errored from all the mirrors so that
  * the pages that are errored in the just handled mirror can be repaired.
  */
-static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
-                               struct scrub_block *sblock, int is_metadata,
-                               int have_csum, u8 *csum, u64 generation,
-                               u16 csum_size)
+static void scrub_recheck_block(struct btrfs_fs_info *fs_info,
+                                struct scrub_block *sblock, int is_metadata,
+                                int have_csum, u8 *csum, u64 generation,
+                                u16 csum_size)
 {
         int page_num;
 
@@ -1062,8 +1276,7 @@ static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
 
         for (page_num = 0; page_num < sblock->page_count; page_num++) {
                 struct bio *bio;
-                int ret;
-                struct scrub_page *page = sblock->pagev + page_num;
+                struct scrub_page *page = sblock->pagev[page_num];
                 DECLARE_COMPLETION_ONSTACK(complete);
 
                 if (page->dev->bdev == NULL) {
@@ -1072,20 +1285,19 @@ static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
                         continue;
                 }
 
-                BUG_ON(!page->page);
+                WARN_ON(!page->page);
                 bio = bio_alloc(GFP_NOFS, 1);
-                if (!bio)
-                        return -EIO;
+                if (!bio) {
+                        page->io_error = 1;
+                        sblock->no_io_error_seen = 0;
+                        continue;
+                }
                 bio->bi_bdev = page->dev->bdev;
                 bio->bi_sector = page->physical >> 9;
                 bio->bi_end_io = scrub_complete_bio_end_io;
                 bio->bi_private = &complete;
 
-                ret = bio_add_page(bio, page->page, PAGE_SIZE, 0);
-                if (PAGE_SIZE != ret) {
-                        bio_put(bio);
-                        return -EIO;
-                }
+                bio_add_page(bio, page->page, PAGE_SIZE, 0);
                 btrfsic_submit_bio(READ, bio);
 
                 /* this will also unplug the queue */
@@ -1102,7 +1314,7 @@ static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
                                              have_csum, csum, generation,
                                              csum_size);
 
-        return 0;
+        return;
 }
 
 static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
@@ -1117,14 +1329,14 @@ static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
         struct btrfs_root *root = fs_info->extent_root;
         void *mapped_buffer;
 
-        BUG_ON(!sblock->pagev[0].page);
+        WARN_ON(!sblock->pagev[0]->page);
         if (is_metadata) {
                 struct btrfs_header *h;
 
-                mapped_buffer = kmap_atomic(sblock->pagev[0].page);
+                mapped_buffer = kmap_atomic(sblock->pagev[0]->page);
                 h = (struct btrfs_header *)mapped_buffer;
 
-                if (sblock->pagev[0].logical != le64_to_cpu(h->bytenr) ||
+                if (sblock->pagev[0]->logical != le64_to_cpu(h->bytenr) ||
                     memcmp(h->fsid, fs_info->fsid, BTRFS_UUID_SIZE) ||
                     memcmp(h->chunk_tree_uuid, fs_info->chunk_tree_uuid,
                            BTRFS_UUID_SIZE)) {
@@ -1138,7 +1350,7 @@ static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
                 if (!have_csum)
                         return;
 
-                mapped_buffer = kmap_atomic(sblock->pagev[0].page);
+                mapped_buffer = kmap_atomic(sblock->pagev[0]->page);
         }
 
         for (page_num = 0;;) {
@@ -1154,9 +1366,9 @@ static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
                 page_num++;
                 if (page_num >= sblock->page_count)
                         break;
-                BUG_ON(!sblock->pagev[page_num].page);
+                WARN_ON(!sblock->pagev[page_num]->page);
 
-                mapped_buffer = kmap_atomic(sblock->pagev[page_num].page);
+                mapped_buffer = kmap_atomic(sblock->pagev[page_num]->page);
         }
 
         btrfs_csum_final(crc, calculated_csum);
@@ -1194,17 +1406,23 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                                             struct scrub_block *sblock_good,
                                             int page_num, int force_write)
 {
-        struct scrub_page *page_bad = sblock_bad->pagev + page_num;
-        struct scrub_page *page_good = sblock_good->pagev + page_num;
+        struct scrub_page *page_bad = sblock_bad->pagev[page_num];
+        struct scrub_page *page_good = sblock_good->pagev[page_num];
 
-        BUG_ON(sblock_bad->pagev[page_num].page == NULL);
-        BUG_ON(sblock_good->pagev[page_num].page == NULL);
+        BUG_ON(page_bad->page == NULL);
+        BUG_ON(page_good->page == NULL);
         if (force_write || sblock_bad->header_error ||
             sblock_bad->checksum_error || page_bad->io_error) {
                 struct bio *bio;
                 int ret;
                 DECLARE_COMPLETION_ONSTACK(complete);
 
+                if (!page_bad->dev->bdev) {
+                        printk_ratelimited(KERN_WARNING
+                                "btrfs: scrub_repair_page_from_good_copy(bdev == NULL) is unexpected!\n");
+                        return -EIO;
+                }
+
                 bio = bio_alloc(GFP_NOFS, 1);
                 if (!bio)
                         return -EIO;
@@ -1225,6 +1443,9 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
                 if (!bio_flagged(bio, BIO_UPTODATE)) {
                         btrfs_dev_stat_inc_and_print(page_bad->dev,
                                 BTRFS_DEV_STAT_WRITE_ERRS);
+                        btrfs_dev_replace_stats_inc(
+                                &sblock_bad->sctx->dev_root->fs_info->
+                                dev_replace.num_write_errors);
                         bio_put(bio);
                         return -EIO;
                 }
@@ -1234,13 +1455,174 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
         return 0;
 }
 
-static void scrub_checksum(struct scrub_block *sblock)
+static void scrub_write_block_to_dev_replace(struct scrub_block *sblock)
+{
+        int page_num;
+
+        for (page_num = 0; page_num < sblock->page_count; page_num++) {
+                int ret;
+
+                ret = scrub_write_page_to_dev_replace(sblock, page_num);
+                if (ret)
+                        btrfs_dev_replace_stats_inc(
+                                &sblock->sctx->dev_root->fs_info->dev_replace.
+                                num_write_errors);
+        }
+}
+
+static int scrub_write_page_to_dev_replace(struct scrub_block *sblock,
+                                           int page_num)
+{
+        struct scrub_page *spage = sblock->pagev[page_num];
+
+        BUG_ON(spage->page == NULL);
+        if (spage->io_error) {
+                void *mapped_buffer = kmap_atomic(spage->page);
+
+                memset(mapped_buffer, 0, PAGE_CACHE_SIZE);
+                flush_dcache_page(spage->page);
+                kunmap_atomic(mapped_buffer);
+        }
+        return scrub_add_page_to_wr_bio(sblock->sctx, spage);
+}
+
+static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,
+                                    struct scrub_page *spage)
+{
+        struct scrub_wr_ctx *wr_ctx = &sctx->wr_ctx;
+        struct scrub_bio *sbio;
+        int ret;
+
+        mutex_lock(&wr_ctx->wr_lock);
+again:
+        if (!wr_ctx->wr_curr_bio) {
+                wr_ctx->wr_curr_bio = kzalloc(sizeof(*wr_ctx->wr_curr_bio),
+                                              GFP_NOFS);
+                if (!wr_ctx->wr_curr_bio) {
+                        mutex_unlock(&wr_ctx->wr_lock);
+                        return -ENOMEM;
+                }
+                wr_ctx->wr_curr_bio->sctx = sctx;
+                wr_ctx->wr_curr_bio->page_count = 0;
+        }
+        sbio = wr_ctx->wr_curr_bio;
+        if (sbio->page_count == 0) {
+                struct bio *bio;
+
+                sbio->physical = spage->physical_for_dev_replace;
+                sbio->logical = spage->logical;
+                sbio->dev = wr_ctx->tgtdev;
+                bio = sbio->bio;
+                if (!bio) {
+                        bio = bio_alloc(GFP_NOFS, wr_ctx->pages_per_wr_bio);
+                        if (!bio) {
+                                mutex_unlock(&wr_ctx->wr_lock);
+                                return -ENOMEM;
+                        }
+                        sbio->bio = bio;
+                }
+
+                bio->bi_private = sbio;
+                bio->bi_end_io = scrub_wr_bio_end_io;
+                bio->bi_bdev = sbio->dev->bdev;
+                bio->bi_sector = sbio->physical >> 9;
+                sbio->err = 0;
+        } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
+                   spage->physical_for_dev_replace ||
+                   sbio->logical + sbio->page_count * PAGE_SIZE !=
+                   spage->logical) {
+                scrub_wr_submit(sctx);
+                goto again;
+        }
+
+        ret = bio_add_page(sbio->bio, spage->page, PAGE_SIZE, 0);
+        if (ret != PAGE_SIZE) {
+                if (sbio->page_count < 1) {
+                        bio_put(sbio->bio);
+                        sbio->bio = NULL;
+                        mutex_unlock(&wr_ctx->wr_lock);
+                        return -EIO;
+                }
+                scrub_wr_submit(sctx);
+                goto again;
+        }
+
+        sbio->pagev[sbio->page_count] = spage;
+        scrub_page_get(spage);
+        sbio->page_count++;
+        if (sbio->page_count == wr_ctx->pages_per_wr_bio)
+                scrub_wr_submit(sctx);
+        mutex_unlock(&wr_ctx->wr_lock);
+
+        return 0;
+}
+
+static void scrub_wr_submit(struct scrub_ctx *sctx)
+{
+        struct scrub_wr_ctx *wr_ctx = &sctx->wr_ctx;
+        struct scrub_bio *sbio;
+
+        if (!wr_ctx->wr_curr_bio)
+                return;
+
+        sbio = wr_ctx->wr_curr_bio;
+        wr_ctx->wr_curr_bio = NULL;
+        WARN_ON(!sbio->bio->bi_bdev);
+        scrub_pending_bio_inc(sctx);
+        /* process all writes in a single worker thread. Then the block layer
+         * orders the requests before sending them to the driver which
+         * doubled the write performance on spinning disks when measured
+         * with Linux 3.5 */
+        btrfsic_submit_bio(WRITE, sbio->bio);
+}
+
+static void scrub_wr_bio_end_io(struct bio *bio, int err)
+{
+        struct scrub_bio *sbio = bio->bi_private;
+        struct btrfs_fs_info *fs_info = sbio->dev->dev_root->fs_info;
+
+        sbio->err = err;
+        sbio->bio = bio;
+
+        sbio->work.func = scrub_wr_bio_end_io_worker;
+        btrfs_queue_worker(&fs_info->scrub_wr_completion_workers, &sbio->work);
+}
+
+static void scrub_wr_bio_end_io_worker(struct btrfs_work *work)
+{
+        struct scrub_bio *sbio = container_of(work, struct scrub_bio, work);
+        struct scrub_ctx *sctx = sbio->sctx;
+        int i;
+
+        WARN_ON(sbio->page_count > SCRUB_PAGES_PER_WR_BIO);
+        if (sbio->err) {
+                struct btrfs_dev_replace *dev_replace =
+                        &sbio->sctx->dev_root->fs_info->dev_replace;
+
+                for (i = 0; i < sbio->page_count; i++) {
+                        struct scrub_page *spage = sbio->pagev[i];
+
+                        spage->io_error = 1;
+                        btrfs_dev_replace_stats_inc(&dev_replace->
+                                                    num_write_errors);
+                }
+        }
+
+        for (i = 0; i < sbio->page_count; i++)
+                scrub_page_put(sbio->pagev[i]);
+
+        bio_put(sbio->bio);
+        kfree(sbio);
+        scrub_pending_bio_dec(sctx);
+}
+
+static int scrub_checksum(struct scrub_block *sblock)
 {
         u64 flags;
         int ret;
 
-        BUG_ON(sblock->page_count < 1);
-        flags = sblock->pagev[0].flags;
+        WARN_ON(sblock->page_count < 1);
+        flags = sblock->pagev[0]->flags;
         ret = 0;
         if (flags & BTRFS_EXTENT_FLAG_DATA)
                 ret = scrub_checksum_data(sblock);
@@ -1252,30 +1634,32 @@ static void scrub_checksum(struct scrub_block *sblock)
                 WARN_ON(1);
         if (ret)
                 scrub_handle_errored_block(sblock);
+
+        return ret;
 }
 
 static int scrub_checksum_data(struct scrub_block *sblock)
 {
-        struct scrub_dev *sdev = sblock->sdev;
+        struct scrub_ctx *sctx = sblock->sctx;
         u8 csum[BTRFS_CSUM_SIZE];
         u8 *on_disk_csum;
         struct page *page;
         void *buffer;
         u32 crc = ~(u32)0;
         int fail = 0;
-        struct btrfs_root *root = sdev->dev->dev_root;
+        struct btrfs_root *root = sctx->dev_root;
         u64 len;
         int index;
 
         BUG_ON(sblock->page_count < 1);
-        if (!sblock->pagev[0].have_csum)
+        if (!sblock->pagev[0]->have_csum)
                 return 0;
 
-        on_disk_csum = sblock->pagev[0].csum;
-        page = sblock->pagev[0].page;
+        on_disk_csum = sblock->pagev[0]->csum;
+        page = sblock->pagev[0]->page;
         buffer = kmap_atomic(page);
 
-        len = sdev->sectorsize;
+        len = sctx->sectorsize;
         index = 0;
         for (;;) {
                 u64 l = min_t(u64, len, PAGE_SIZE);
@@ -1287,13 +1671,13 @@ static int scrub_checksum_data(struct scrub_block *sblock)
                         break;
                 index++;
                 BUG_ON(index >= sblock->page_count);
-                BUG_ON(!sblock->pagev[index].page);
-                page = sblock->pagev[index].page;
+                BUG_ON(!sblock->pagev[index]->page);
+                page = sblock->pagev[index]->page;
                 buffer = kmap_atomic(page);
         }
 
         btrfs_csum_final(crc, csum);
-        if (memcmp(csum, on_disk_csum, sdev->csum_size))
+        if (memcmp(csum, on_disk_csum, sctx->csum_size))
                 fail = 1;
 
         return fail;
@@ -1301,9 +1685,9 @@ static int scrub_checksum_data(struct scrub_block *sblock)
 
 static int scrub_checksum_tree_block(struct scrub_block *sblock)
 {
-        struct scrub_dev *sdev = sblock->sdev;
+        struct scrub_ctx *sctx = sblock->sctx;
         struct btrfs_header *h;
-        struct btrfs_root *root = sdev->dev->dev_root;
+        struct btrfs_root *root = sctx->dev_root;
         struct btrfs_fs_info *fs_info = root->fs_info;
         u8 calculated_csum[BTRFS_CSUM_SIZE];
         u8 on_disk_csum[BTRFS_CSUM_SIZE];
@@ -1318,10 +1702,10 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
         int index;
 
         BUG_ON(sblock->page_count < 1);
-        page = sblock->pagev[0].page;
+        page = sblock->pagev[0]->page;
         mapped_buffer = kmap_atomic(page);
         h = (struct btrfs_header *)mapped_buffer;
-        memcpy(on_disk_csum, h->csum, sdev->csum_size);
+        memcpy(on_disk_csum, h->csum, sctx->csum_size);
 
         /*
          * we don't use the getter functions here, as we
@@ -1329,10 +1713,10 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
          * b) the page is already kmapped
          */
 
-        if (sblock->pagev[0].logical != le64_to_cpu(h->bytenr))
+        if (sblock->pagev[0]->logical != le64_to_cpu(h->bytenr))
                 ++fail;
 
-        if (sblock->pagev[0].generation != le64_to_cpu(h->generation))
+        if (sblock->pagev[0]->generation != le64_to_cpu(h->generation))
                 ++fail;
 
         if (memcmp(h->fsid, fs_info->fsid, BTRFS_UUID_SIZE))
@@ -1342,8 +1726,8 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
                    BTRFS_UUID_SIZE))
                 ++fail;
 
-        BUG_ON(sdev->nodesize != sdev->leafsize);
-        len = sdev->nodesize - BTRFS_CSUM_SIZE;
+        WARN_ON(sctx->nodesize != sctx->leafsize);
+        len = sctx->nodesize - BTRFS_CSUM_SIZE;
         mapped_size = PAGE_SIZE - BTRFS_CSUM_SIZE;
         p = ((u8 *)mapped_buffer) + BTRFS_CSUM_SIZE;
         index = 0;
@@ -1357,15 +1741,15 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
                         break;
                 index++;
                 BUG_ON(index >= sblock->page_count);
-                BUG_ON(!sblock->pagev[index].page);
-                page = sblock->pagev[index].page;
+                BUG_ON(!sblock->pagev[index]->page);
+                page = sblock->pagev[index]->page;
                 mapped_buffer = kmap_atomic(page);
                 mapped_size = PAGE_SIZE;
                 p = mapped_buffer;
         }
 
         btrfs_csum_final(crc, calculated_csum);
-        if (memcmp(calculated_csum, on_disk_csum, sdev->csum_size))
+        if (memcmp(calculated_csum, on_disk_csum, sctx->csum_size))
                 ++crc_fail;
 
         return fail || crc_fail;
@@ -1374,8 +1758,8 @@ static int scrub_checksum_tree_block(struct scrub_block *sblock)
 static int scrub_checksum_super(struct scrub_block *sblock)
 {
         struct btrfs_super_block *s;
-        struct scrub_dev *sdev = sblock->sdev;
-        struct btrfs_root *root = sdev->dev->dev_root;
+        struct scrub_ctx *sctx = sblock->sctx;
+        struct btrfs_root *root = sctx->dev_root;
         struct btrfs_fs_info *fs_info = root->fs_info;
         u8 calculated_csum[BTRFS_CSUM_SIZE];
         u8 on_disk_csum[BTRFS_CSUM_SIZE];
@@ -1390,15 +1774,15 @@ static int scrub_checksum_super(struct scrub_block *sblock)
         int index;
 
         BUG_ON(sblock->page_count < 1);
-        page = sblock->pagev[0].page;
+        page = sblock->pagev[0]->page;
         mapped_buffer = kmap_atomic(page);
         s = (struct btrfs_super_block *)mapped_buffer;
-        memcpy(on_disk_csum, s->csum, sdev->csum_size);
+        memcpy(on_disk_csum, s->csum, sctx->csum_size);
 
-        if (sblock->pagev[0].logical != le64_to_cpu(s->bytenr))
+        if (sblock->pagev[0]->logical != le64_to_cpu(s->bytenr))
                 ++fail_cor;
 
-        if (sblock->pagev[0].generation != le64_to_cpu(s->generation))
+        if (sblock->pagev[0]->generation != le64_to_cpu(s->generation))
                 ++fail_gen;
 
         if (memcmp(s->fsid, fs_info->fsid, BTRFS_UUID_SIZE))
@@ -1418,15 +1802,15 @@ static int scrub_checksum_super(struct scrub_block *sblock)
                         break;
                 index++;
                 BUG_ON(index >= sblock->page_count);
-                BUG_ON(!sblock->pagev[index].page);
-                page = sblock->pagev[index].page;
+                BUG_ON(!sblock->pagev[index]->page);
+                page = sblock->pagev[index]->page;
                 mapped_buffer = kmap_atomic(page);
                 mapped_size = PAGE_SIZE;
                 p = mapped_buffer;
         }
 
         btrfs_csum_final(crc, calculated_csum);
-        if (memcmp(calculated_csum, on_disk_csum, sdev->csum_size))
+        if (memcmp(calculated_csum, on_disk_csum, sctx->csum_size))
                 ++fail_cor;
 
         if (fail_cor + fail_gen) {
@@ -1435,14 +1819,14 @@ static int scrub_checksum_super(struct scrub_block *sblock)
                  * They will get written with the next transaction commit
                  * anyway
                  */
-                spin_lock(&sdev->stat_lock);
-                ++sdev->stat.super_errors;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                ++sctx->stat.super_errors;
+                spin_unlock(&sctx->stat_lock);
                 if (fail_cor)
-                        btrfs_dev_stat_inc_and_print(sdev->dev,
+                        btrfs_dev_stat_inc_and_print(sblock->pagev[0]->dev,
                                 BTRFS_DEV_STAT_CORRUPTION_ERRS);
                 else
-                        btrfs_dev_stat_inc_and_print(sdev->dev,
+                        btrfs_dev_stat_inc_and_print(sblock->pagev[0]->dev,
                                 BTRFS_DEV_STAT_GENERATION_ERRS);
         }
 
@@ -1460,28 +1844,54 @@ static void scrub_block_put(struct scrub_block *sblock)
                 int i;
 
                 for (i = 0; i < sblock->page_count; i++)
-                        if (sblock->pagev[i].page)
-                                __free_page(sblock->pagev[i].page);
+                        scrub_page_put(sblock->pagev[i]);
                 kfree(sblock);
         }
 }
 
-static void scrub_submit(struct scrub_dev *sdev)
+static void scrub_page_get(struct scrub_page *spage)
+{
+        atomic_inc(&spage->ref_count);
+}
+
+static void scrub_page_put(struct scrub_page *spage)
+{
+        if (atomic_dec_and_test(&spage->ref_count)) {
+                if (spage->page)
+                        __free_page(spage->page);
+                kfree(spage);
+        }
+}
+
+static void scrub_submit(struct scrub_ctx *sctx)
 {
         struct scrub_bio *sbio;
 
-        if (sdev->curr == -1)
+        if (sctx->curr == -1)
                 return;
 
-        sbio = sdev->bios[sdev->curr];
-        sdev->curr = -1;
-        atomic_inc(&sdev->in_flight);
+        sbio = sctx->bios[sctx->curr];
+        sctx->curr = -1;
+        scrub_pending_bio_inc(sctx);
 
-        btrfsic_submit_bio(READ, sbio->bio);
+        if (!sbio->bio->bi_bdev) {
+                /*
+                 * this case should not happen. If btrfs_map_block() is
+                 * wrong, it could happen for dev-replace operations on
+                 * missing devices when no mirrors are available, but in
+                 * this case it should already fail the mount.
+                 * This case is handled correctly (but _very_ slowly).
+                 */
+                printk_ratelimited(KERN_WARNING
+                        "btrfs: scrub_submit(bio bdev == NULL) is unexpected!\n");
+                bio_endio(sbio->bio, -EIO);
+        } else {
+                btrfsic_submit_bio(READ, sbio->bio);
+        }
 }
 
-static int scrub_add_page_to_bio(struct scrub_dev *sdev,
-                                 struct scrub_page *spage)
+static int scrub_add_page_to_rd_bio(struct scrub_ctx *sctx,
+                                    struct scrub_page *spage)
 {
         struct scrub_block *sblock = spage->sblock;
         struct scrub_bio *sbio;
@@ -1491,28 +1901,29 @@ again:
         /*
          * grab a fresh bio or wait for one to become available
          */
-        while (sdev->curr == -1) {
-                spin_lock(&sdev->list_lock);
-                sdev->curr = sdev->first_free;
-                if (sdev->curr != -1) {
-                        sdev->first_free = sdev->bios[sdev->curr]->next_free;
-                        sdev->bios[sdev->curr]->next_free = -1;
-                        sdev->bios[sdev->curr]->page_count = 0;
-                        spin_unlock(&sdev->list_lock);
+        while (sctx->curr == -1) {
+                spin_lock(&sctx->list_lock);
+                sctx->curr = sctx->first_free;
+                if (sctx->curr != -1) {
+                        sctx->first_free = sctx->bios[sctx->curr]->next_free;
+                        sctx->bios[sctx->curr]->next_free = -1;
+                        sctx->bios[sctx->curr]->page_count = 0;
+                        spin_unlock(&sctx->list_lock);
                 } else {
-                        spin_unlock(&sdev->list_lock);
-                        wait_event(sdev->list_wait, sdev->first_free != -1);
+                        spin_unlock(&sctx->list_lock);
+                        wait_event(sctx->list_wait, sctx->first_free != -1);
                 }
         }
-        sbio = sdev->bios[sdev->curr];
+        sbio = sctx->bios[sctx->curr];
         if (sbio->page_count == 0) {
                 struct bio *bio;
 
                 sbio->physical = spage->physical;
                 sbio->logical = spage->logical;
+                sbio->dev = spage->dev;
                 bio = sbio->bio;
                 if (!bio) {
-                        bio = bio_alloc(GFP_NOFS, sdev->pages_per_bio);
+                        bio = bio_alloc(GFP_NOFS, sctx->pages_per_rd_bio);
                         if (!bio)
                                 return -ENOMEM;
                         sbio->bio = bio;
@@ -1520,14 +1931,15 @@ again:
 
                 bio->bi_private = sbio;
                 bio->bi_end_io = scrub_bio_end_io;
-                bio->bi_bdev = sdev->dev->bdev;
-                bio->bi_sector = spage->physical >> 9;
+                bio->bi_bdev = sbio->dev->bdev;
+                bio->bi_sector = sbio->physical >> 9;
                 sbio->err = 0;
         } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                    spage->physical ||
                    sbio->logical + sbio->page_count * PAGE_SIZE !=
-                   spage->logical) {
-                scrub_submit(sdev);
+                   spage->logical ||
+                   sbio->dev != spage->dev) {
+                scrub_submit(sctx);
                 goto again;
         }
 
@@ -1539,81 +1951,87 @@ again:
                         sbio->bio = NULL;
                         return -EIO;
                 }
-                scrub_submit(sdev);
+                scrub_submit(sctx);
                 goto again;
         }
 
-        scrub_block_get(sblock); /* one for the added page */
+        scrub_block_get(sblock); /* one for the page added to the bio */
         atomic_inc(&sblock->outstanding_pages);
         sbio->page_count++;
-        if (sbio->page_count == sdev->pages_per_bio)
-                scrub_submit(sdev);
+        if (sbio->page_count == sctx->pages_per_rd_bio)
+                scrub_submit(sctx);
 
         return 0;
 }
 
-static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len,
-                       u64 physical, u64 flags, u64 gen, int mirror_num,
-                       u8 *csum, int force)
+static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
+                       u64 physical, struct btrfs_device *dev, u64 flags,
+                       u64 gen, int mirror_num, u8 *csum, int force,
+                       u64 physical_for_dev_replace)
 {
         struct scrub_block *sblock;
         int index;
 
         sblock = kzalloc(sizeof(*sblock), GFP_NOFS);
         if (!sblock) {
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.malloc_errors++;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.malloc_errors++;
+                spin_unlock(&sctx->stat_lock);
                 return -ENOMEM;
         }
 
-        /* one ref inside this function, plus one for each page later on */
+        /* one ref inside this function, plus one for each page added to
+         * a bio later on */
         atomic_set(&sblock->ref_count, 1);
-        sblock->sdev = sdev;
+        sblock->sctx = sctx;
         sblock->no_io_error_seen = 1;
 
         for (index = 0; len > 0; index++) {
-                struct scrub_page *spage = sblock->pagev + index;
+                struct scrub_page *spage;
                 u64 l = min_t(u64, len, PAGE_SIZE);
 
-                BUG_ON(index >= SCRUB_MAX_PAGES_PER_BLOCK);
-                spage->page = alloc_page(GFP_NOFS);
-                if (!spage->page) {
-                        spin_lock(&sdev->stat_lock);
-                        sdev->stat.malloc_errors++;
-                        spin_unlock(&sdev->stat_lock);
-                        while (index > 0) {
-                                index--;
-                                __free_page(sblock->pagev[index].page);
-                        }
-                        kfree(sblock);
+                spage = kzalloc(sizeof(*spage), GFP_NOFS);
+                if (!spage) {
+leave_nomem:
+                        spin_lock(&sctx->stat_lock);
+                        sctx->stat.malloc_errors++;
+                        spin_unlock(&sctx->stat_lock);
+                        scrub_block_put(sblock);
                         return -ENOMEM;
                 }
+                BUG_ON(index >= SCRUB_MAX_PAGES_PER_BLOCK);
+                scrub_page_get(spage);
+                sblock->pagev[index] = spage;
                 spage->sblock = sblock;
-                spage->dev = sdev->dev;
+                spage->dev = dev;
                 spage->flags = flags;
                 spage->generation = gen;
                 spage->logical = logical;
                 spage->physical = physical;
+                spage->physical_for_dev_replace = physical_for_dev_replace;
                 spage->mirror_num = mirror_num;
                 if (csum) {
                         spage->have_csum = 1;
-                        memcpy(spage->csum, csum, sdev->csum_size);
+                        memcpy(spage->csum, csum, sctx->csum_size);
                 } else {
                         spage->have_csum = 0;
                 }
                 sblock->page_count++;
+                spage->page = alloc_page(GFP_NOFS);
+                if (!spage->page)
+                        goto leave_nomem;
                 len -= l;
                 logical += l;
                 physical += l;
+                physical_for_dev_replace += l;
         }
 
-        BUG_ON(sblock->page_count == 0);
+        WARN_ON(sblock->page_count == 0);
         for (index = 0; index < sblock->page_count; index++) {
-                struct scrub_page *spage = sblock->pagev + index;
+                struct scrub_page *spage = sblock->pagev[index];
                 int ret;
 
-                ret = scrub_add_page_to_bio(sdev, spage);
+                ret = scrub_add_page_to_rd_bio(sctx, spage);
                 if (ret) {
                         scrub_block_put(sblock);
                         return ret;
@@ -1621,7 +2039,7 @@ static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len,
         }
 
         if (force)
-                scrub_submit(sdev);
+                scrub_submit(sctx);
 
         /* last one frees, either here or in bio completion for last page */
         scrub_block_put(sblock);
@@ -1631,8 +2049,7 @@ static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len,
 static void scrub_bio_end_io(struct bio *bio, int err)
 {
         struct scrub_bio *sbio = bio->bi_private;
-        struct scrub_dev *sdev = sbio->sdev;
-        struct btrfs_fs_info *fs_info = sdev->dev->dev_root->fs_info;
+        struct btrfs_fs_info *fs_info = sbio->dev->dev_root->fs_info;
 
         sbio->err = err;
         sbio->bio = bio;
@@ -1643,10 +2060,10 @@ static void scrub_bio_end_io(struct bio *bio, int err)
 static void scrub_bio_end_io_worker(struct btrfs_work *work)
 {
         struct scrub_bio *sbio = container_of(work, struct scrub_bio, work);
-        struct scrub_dev *sdev = sbio->sdev;
+        struct scrub_ctx *sctx = sbio->sctx;
         int i;
 
-        BUG_ON(sbio->page_count > SCRUB_PAGES_PER_BIO);
+        BUG_ON(sbio->page_count > SCRUB_PAGES_PER_RD_BIO);
         if (sbio->err) {
                 for (i = 0; i < sbio->page_count; i++) {
                         struct scrub_page *spage = sbio->pagev[i];
@@ -1666,40 +2083,39 @@ static void scrub_bio_end_io_worker(struct btrfs_work *work)
                 scrub_block_put(sblock);
         }
 
-        if (sbio->err) {
-                /* what is this good for??? */
-                sbio->bio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                sbio->bio->bi_flags |= 1 << BIO_UPTODATE;
-                sbio->bio->bi_phys_segments = 0;
-                sbio->bio->bi_idx = 0;
+        bio_put(sbio->bio);
+        sbio->bio = NULL;
+        spin_lock(&sctx->list_lock);
+        sbio->next_free = sctx->first_free;
+        sctx->first_free = sbio->index;
+        spin_unlock(&sctx->list_lock);
 
-                for (i = 0; i < sbio->page_count; i++) {
-                        struct bio_vec *bi;
-                        bi = &sbio->bio->bi_io_vec[i];
-                        bi->bv_offset = 0;
-                        bi->bv_len = PAGE_SIZE;
-                }
+        if (sctx->is_dev_replace &&
+            atomic_read(&sctx->wr_ctx.flush_all_writes)) {
+                mutex_lock(&sctx->wr_ctx.wr_lock);
+                scrub_wr_submit(sctx);
+                mutex_unlock(&sctx->wr_ctx.wr_lock);
         }
 
-        bio_put(sbio->bio);
-        sbio->bio = NULL;
-        spin_lock(&sdev->list_lock);
-        sbio->next_free = sdev->first_free;
-        sdev->first_free = sbio->index;
-        spin_unlock(&sdev->list_lock);
-        atomic_dec(&sdev->in_flight);
-        wake_up(&sdev->list_wait);
+        scrub_pending_bio_dec(sctx);
 }
 
 static void scrub_block_complete(struct scrub_block *sblock)
 {
-        if (!sblock->no_io_error_seen)
+        if (!sblock->no_io_error_seen) {
                 scrub_handle_errored_block(sblock);
-        else
-                scrub_checksum(sblock);
+        } else {
+                /*
+                 * if has checksum error, write via repair mechanism in
+                 * dev replace case, otherwise write here in dev replace
+                 * case.
+                 */
+                if (!scrub_checksum(sblock) && sblock->sctx->is_dev_replace)
+                        scrub_write_block_to_dev_replace(sblock);
+        }
 }
 
-static int scrub_find_csum(struct scrub_dev *sdev, u64 logical, u64 len,
+static int scrub_find_csum(struct scrub_ctx *sctx, u64 logical, u64 len,
                            u8 *csum)
 {
         struct btrfs_ordered_sum *sum = NULL;
@@ -1707,15 +2123,15 @@ static int scrub_find_csum(struct scrub_dev *sdev, u64 logical, u64 len,
         unsigned long i;
         unsigned long num_sectors;
 
-        while (!list_empty(&sdev->csum_list)) {
-                sum = list_first_entry(&sdev->csum_list,
+        while (!list_empty(&sctx->csum_list)) {
+                sum = list_first_entry(&sctx->csum_list,
                                        struct btrfs_ordered_sum, list);
                 if (sum->bytenr > logical)
                         return 0;
                 if (sum->bytenr + sum->len > logical)
                         break;
 
-                ++sdev->stat.csum_discards;
+                ++sctx->stat.csum_discards;
                 list_del(&sum->list);
                 kfree(sum);
                 sum = NULL;
@@ -1723,10 +2139,10 @@ static int scrub_find_csum(struct scrub_dev *sdev, u64 logical, u64 len,
         if (!sum)
                 return 0;
 
-        num_sectors = sum->len / sdev->sectorsize;
+        num_sectors = sum->len / sctx->sectorsize;
         for (i = 0; i < num_sectors; ++i) {
                 if (sum->sums[i].bytenr == logical) {
-                        memcpy(csum, &sum->sums[i].sum, sdev->csum_size);
+                        memcpy(csum, &sum->sums[i].sum, sctx->csum_size);
                         ret = 1;
                         break;
                 }
@@ -1739,29 +2155,30 @@ static int scrub_find_csum(struct scrub_dev *sdev, u64 logical, u64 len,
 }
 
 /* scrub extent tries to collect up to 64 kB for each bio */
-static int scrub_extent(struct scrub_dev *sdev, u64 logical, u64 len,
-                        u64 physical, u64 flags, u64 gen, int mirror_num)
+static int scrub_extent(struct scrub_ctx *sctx, u64 logical, u64 len,
+                        u64 physical, struct btrfs_device *dev, u64 flags,
+                        u64 gen, int mirror_num, u64 physical_for_dev_replace)
 {
         int ret;
         u8 csum[BTRFS_CSUM_SIZE];
         u32 blocksize;
 
         if (flags & BTRFS_EXTENT_FLAG_DATA) {
-                blocksize = sdev->sectorsize;
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.data_extents_scrubbed++;
-                sdev->stat.data_bytes_scrubbed += len;
-                spin_unlock(&sdev->stat_lock);
+                blocksize = sctx->sectorsize;
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.data_extents_scrubbed++;
+                sctx->stat.data_bytes_scrubbed += len;
+                spin_unlock(&sctx->stat_lock);
         } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
-                BUG_ON(sdev->nodesize != sdev->leafsize);
-                blocksize = sdev->nodesize;
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.tree_extents_scrubbed++;
-                sdev->stat.tree_bytes_scrubbed += len;
-                spin_unlock(&sdev->stat_lock);
+                WARN_ON(sctx->nodesize != sctx->leafsize);
+                blocksize = sctx->nodesize;
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.tree_extents_scrubbed++;
+                sctx->stat.tree_bytes_scrubbed += len;
+                spin_unlock(&sctx->stat_lock);
         } else {
-                blocksize = sdev->sectorsize;
-                BUG_ON(1);
+                blocksize = sctx->sectorsize;
+                WARN_ON(1);
         }
 
         while (len) {
@@ -1770,26 +2187,38 @@ static int scrub_extent(struct scrub_dev *sdev, u64 logical, u64 len,
 
                 if (flags & BTRFS_EXTENT_FLAG_DATA) {
                         /* push csums to sbio */
-                        have_csum = scrub_find_csum(sdev, logical, l, csum);
+                        have_csum = scrub_find_csum(sctx, logical, l, csum);
                         if (have_csum == 0)
-                                ++sdev->stat.no_csum;
+                                ++sctx->stat.no_csum;
+                        if (sctx->is_dev_replace && !have_csum) {
+                                ret = copy_nocow_pages(sctx, logical, l,
+                                                       mirror_num,
+                                                      physical_for_dev_replace);
+                                goto behind_scrub_pages;
+                        }
                 }
-                ret = scrub_pages(sdev, logical, l, physical, flags, gen,
-                                  mirror_num, have_csum ? csum : NULL, 0);
+                ret = scrub_pages(sctx, logical, l, physical, dev, flags, gen,
+                                  mirror_num, have_csum ? csum : NULL, 0,
+                                  physical_for_dev_replace);
+behind_scrub_pages:
                 if (ret)
                         return ret;
                 len -= l;
                 logical += l;
                 physical += l;
+                physical_for_dev_replace += l;
         }
         return 0;
 }
 
-static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
-        struct map_lookup *map, int num, u64 base, u64 length)
+static noinline_for_stack int scrub_stripe(struct scrub_ctx *sctx,
+                                           struct map_lookup *map,
+                                           struct btrfs_device *scrub_dev,
+                                           int num, u64 base, u64 length,
+                                           int is_dev_replace)
 {
         struct btrfs_path *path;
-        struct btrfs_fs_info *fs_info = sdev->dev->dev_root->fs_info;
+        struct btrfs_fs_info *fs_info = sctx->dev_root->fs_info;
         struct btrfs_root *root = fs_info->extent_root;
         struct btrfs_root *csum_root = fs_info->csum_root;
         struct btrfs_extent_item *extent;
@@ -1809,9 +2238,13 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
         struct reada_control *reada2;
         struct btrfs_key key_start;
         struct btrfs_key key_end;
-
         u64 increment = map->stripe_len;
         u64 offset;
+        u64 extent_logical;
+        u64 extent_physical;
+        u64 extent_len;
+        struct btrfs_device *extent_dev;
+        int extent_mirror_num;
 
         nstripes = length;
         offset = 0;
@@ -1855,8 +2288,8 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
          */
         logical = base + offset;
 
-        wait_event(sdev->list_wait,
-                   atomic_read(&sdev->in_flight) == 0);
+        wait_event(sctx->list_wait,
+                   atomic_read(&sctx->bios_in_flight) == 0);
         atomic_inc(&fs_info->scrubs_paused);
         wake_up(&fs_info->scrub_pause_wait);
 
@@ -1910,7 +2343,7 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
                  * canceled?
                  */
                 if (atomic_read(&fs_info->scrub_cancel_req) ||
-                    atomic_read(&sdev->cancel_req)) {
+                    atomic_read(&sctx->cancel_req)) {
                         ret = -ECANCELED;
                         goto out;
                 }
@@ -1919,9 +2352,14 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
                  */
                 if (atomic_read(&fs_info->scrub_pause_req)) {
                         /* push queued extents */
-                        scrub_submit(sdev);
-                        wait_event(sdev->list_wait,
-                                   atomic_read(&sdev->in_flight) == 0);
+                        atomic_set(&sctx->wr_ctx.flush_all_writes, 1);
+                        scrub_submit(sctx);
+                        mutex_lock(&sctx->wr_ctx.wr_lock);
+                        scrub_wr_submit(sctx);
+                        mutex_unlock(&sctx->wr_ctx.wr_lock);
+                        wait_event(sctx->list_wait,
+                                   atomic_read(&sctx->bios_in_flight) == 0);
+                        atomic_set(&sctx->wr_ctx.flush_all_writes, 0);
                         atomic_inc(&fs_info->scrubs_paused);
                         wake_up(&fs_info->scrub_pause_wait);
                         mutex_lock(&fs_info->scrub_lock);
@@ -1938,7 +2376,7 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
 
                 ret = btrfs_lookup_csums_range(csum_root, logical,
                                                logical + map->stripe_len - 1,
-                                               &sdev->csum_list, 1);
+                                               &sctx->csum_list, 1);
                 if (ret)
                         goto out;
 
@@ -2016,9 +2454,20 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
                                              key.objectid;
                         }
 
-                        ret = scrub_extent(sdev, key.objectid, key.offset,
-                                           key.objectid - logical + physical,
-                                           flags, generation, mirror_num);
+                        extent_logical = key.objectid;
+                        extent_physical = key.objectid - logical + physical;
+                        extent_len = key.offset;
+                        extent_dev = scrub_dev;
+                        extent_mirror_num = mirror_num;
+                        if (is_dev_replace)
+                                scrub_remap_extent(fs_info, extent_logical,
+                                                   extent_len, &extent_physical,
+                                                   &extent_dev,
+                                                   &extent_mirror_num);
+                        ret = scrub_extent(sctx, extent_logical, extent_len,
+                                           extent_physical, extent_dev, flags,
+                                           generation, extent_mirror_num,
+                                           key.objectid - logical + physical);
                         if (ret)
                                 goto out;
 
@@ -2028,29 +2477,34 @@ next:
                 btrfs_release_path(path);
                 logical += increment;
                 physical += map->stripe_len;
-                spin_lock(&sdev->stat_lock);
-                sdev->stat.last_physical = physical;
-                spin_unlock(&sdev->stat_lock);
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.last_physical = physical;
+                spin_unlock(&sctx->stat_lock);
         }
+out:
         /* push queued extents */
-        scrub_submit(sdev);
+        scrub_submit(sctx);
+        mutex_lock(&sctx->wr_ctx.wr_lock);
+        scrub_wr_submit(sctx);
+        mutex_unlock(&sctx->wr_ctx.wr_lock);
 
-out:
         blk_finish_plug(&plug);
         btrfs_free_path(path);
         return ret < 0 ? ret : 0;
 }
 
-static noinline_for_stack int scrub_chunk(struct scrub_dev *sdev,
-        u64 chunk_tree, u64 chunk_objectid, u64 chunk_offset, u64 length,
-        u64 dev_offset)
+static noinline_for_stack int scrub_chunk(struct scrub_ctx *sctx,
+                                          struct btrfs_device *scrub_dev,
+                                          u64 chunk_tree, u64 chunk_objectid,
+                                          u64 chunk_offset, u64 length,
+                                          u64 dev_offset, int is_dev_replace)
 {
         struct btrfs_mapping_tree *map_tree =
-                &sdev->dev->dev_root->fs_info->mapping_tree;
+                &sctx->dev_root->fs_info->mapping_tree;
         struct map_lookup *map;
         struct extent_map *em;
         int i;
-        int ret = -EINVAL;
+        int ret = 0;
 
         read_lock(&map_tree->map_tree.lock);
         em = lookup_extent_mapping(&map_tree->map_tree, chunk_offset, 1);
@@ -2067,9 +2521,11 @@ static noinline_for_stack int scrub_chunk(struct scrub_dev *sdev,
                 goto out;
 
         for (i = 0; i < map->num_stripes; ++i) {
-                if (map->stripes[i].dev == sdev->dev &&
+                if (map->stripes[i].dev->bdev == scrub_dev->bdev &&
                     map->stripes[i].physical == dev_offset) {
-                        ret = scrub_stripe(sdev, map, i, chunk_offset, length);
+                        ret = scrub_stripe(sctx, map, scrub_dev, i,
+                                           chunk_offset, length,
+                                           is_dev_replace);
                         if (ret)
                                 goto out;
                 }
@@ -2081,11 +2537,13 @@ out:
 }
 
 static noinline_for_stack
-int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
+int scrub_enumerate_chunks(struct scrub_ctx *sctx,
+                           struct btrfs_device *scrub_dev, u64 start, u64 end,
+                           int is_dev_replace)
 {
         struct btrfs_dev_extent *dev_extent = NULL;
         struct btrfs_path *path;
-        struct btrfs_root *root = sdev->dev->dev_root;
+        struct btrfs_root *root = sctx->dev_root;
         struct btrfs_fs_info *fs_info = root->fs_info;
         u64 length;
         u64 chunk_tree;
@@ -2097,6 +2555,7 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
         struct btrfs_key key;
         struct btrfs_key found_key;
         struct btrfs_block_group_cache *cache;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
 
         path = btrfs_alloc_path();
         if (!path)
@@ -2106,11 +2565,10 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
         path->search_commit_root = 1;
         path->skip_locking = 1;
 
-        key.objectid = sdev->dev->devid;
+        key.objectid = scrub_dev->devid;
         key.offset = 0ull;
         key.type = BTRFS_DEV_EXTENT_KEY;
 
-
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
@@ -2129,7 +2587,7 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
 
                 btrfs_item_key_to_cpu(l, &found_key, slot);
 
-                if (found_key.objectid != sdev->dev->devid)
+                if (found_key.objectid != scrub_dev->devid)
                         break;
 
                 if (btrfs_key_type(&found_key) != BTRFS_DEV_EXTENT_KEY)
@@ -2163,11 +2621,62 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
                         ret = -ENOENT;
                         break;
                 }
-                ret = scrub_chunk(sdev, chunk_tree, chunk_objectid,
-                                  chunk_offset, length, found_key.offset);
+                dev_replace->cursor_right = found_key.offset + length;
+                dev_replace->cursor_left = found_key.offset;
+                dev_replace->item_needs_writeback = 1;
+                ret = scrub_chunk(sctx, scrub_dev, chunk_tree, chunk_objectid,
+                                  chunk_offset, length, found_key.offset,
+                                  is_dev_replace);
+
+                /*
+                 * flush, submit all pending read and write bios, afterwards
+                 * wait for them.
+                 * Note that in the dev replace case, a read request causes
+                 * write requests that are submitted in the read completion
+                 * worker. Therefore in the current situation, it is required
+                 * that all write requests are flushed, so that all read and
+                 * write requests are really completed when bios_in_flight
+                 * changes to 0.
+                 */
+                atomic_set(&sctx->wr_ctx.flush_all_writes, 1);
+                scrub_submit(sctx);
+                mutex_lock(&sctx->wr_ctx.wr_lock);
+                scrub_wr_submit(sctx);
+                mutex_unlock(&sctx->wr_ctx.wr_lock);
+
+                wait_event(sctx->list_wait,
+                           atomic_read(&sctx->bios_in_flight) == 0);
+                atomic_set(&sctx->wr_ctx.flush_all_writes, 0);
+                atomic_inc(&fs_info->scrubs_paused);
+                wake_up(&fs_info->scrub_pause_wait);
+                wait_event(sctx->list_wait,
+                           atomic_read(&sctx->workers_pending) == 0);
+
+                mutex_lock(&fs_info->scrub_lock);
+                while (atomic_read(&fs_info->scrub_pause_req)) {
+                        mutex_unlock(&fs_info->scrub_lock);
+                        wait_event(fs_info->scrub_pause_wait,
+                           atomic_read(&fs_info->scrub_pause_req) == 0);
+                        mutex_lock(&fs_info->scrub_lock);
+                }
+                atomic_dec(&fs_info->scrubs_paused);
+                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;
+                if (is_dev_replace &&
+                    atomic64_read(&dev_replace->num_write_errors) > 0) {
+                        ret = -EIO;
+                        break;
+                }
+                if (sctx->stat.malloc_errors > 0) {
+                        ret = -ENOMEM;
+                        break;
+                }
 
                 key.offset = found_key.offset + length;
                 btrfs_release_path(path);
@@ -2182,14 +2691,14 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
         return ret < 0 ? ret : 0;
 }
 
-static noinline_for_stack int scrub_supers(struct scrub_dev *sdev)
+static noinline_for_stack int scrub_supers(struct scrub_ctx *sctx,
+                                           struct btrfs_device *scrub_dev)
 {
         int     i;
         u64     bytenr;
         u64     gen;
         int     ret;
-        struct btrfs_device *device = sdev->dev;
-        struct btrfs_root *root = device->dev_root;
+        struct btrfs_root *root = sctx->dev_root;
 
         if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
                 return -EIO;
@@ -2198,15 +2707,16 @@ static noinline_for_stack int scrub_supers(struct scrub_dev *sdev)
 
         for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
                 bytenr = btrfs_sb_offset(i);
-                if (bytenr + BTRFS_SUPER_INFO_SIZE > device->total_bytes)
+                if (bytenr + BTRFS_SUPER_INFO_SIZE > scrub_dev->total_bytes)
                         break;
 
-                ret = scrub_pages(sdev, bytenr, BTRFS_SUPER_INFO_SIZE, bytenr,
-                                     BTRFS_EXTENT_FLAG_SUPER, gen, i, NULL, 1);
+                ret = scrub_pages(sctx, bytenr, BTRFS_SUPER_INFO_SIZE, bytenr,
+                                  scrub_dev, BTRFS_EXTENT_FLAG_SUPER, gen, i,
+                                  NULL, 1, bytenr);
                 if (ret)
                         return ret;
         }
-        wait_event(sdev->list_wait, atomic_read(&sdev->in_flight) == 0);
+        wait_event(sctx->list_wait, atomic_read(&sctx->bios_in_flight) == 0);
 
         return 0;
 }
@@ -2214,19 +2724,38 @@ static noinline_for_stack int scrub_supers(struct scrub_dev *sdev)
 /*
  * get a reference count on fs_info->scrub_workers. start worker if necessary
  */
-static noinline_for_stack int scrub_workers_get(struct btrfs_root *root)
+static noinline_for_stack int scrub_workers_get(struct btrfs_fs_info *fs_info,
+                                                int is_dev_replace)
 {
-        struct btrfs_fs_info *fs_info = root->fs_info;
         int ret = 0;
 
         mutex_lock(&fs_info->scrub_lock);
         if (fs_info->scrub_workers_refcnt == 0) {
-                btrfs_init_workers(&fs_info->scrub_workers, "scrub",
-                           fs_info->thread_pool_size, &fs_info->generic_worker);
+                if (is_dev_replace)
+                        btrfs_init_workers(&fs_info->scrub_workers, "scrub", 1,
+                                        &fs_info->generic_worker);
+                else
+                        btrfs_init_workers(&fs_info->scrub_workers, "scrub",
+                                        fs_info->thread_pool_size,
+                                        &fs_info->generic_worker);
                 fs_info->scrub_workers.idle_thresh = 4;
                 ret = btrfs_start_workers(&fs_info->scrub_workers);
                 if (ret)
                         goto out;
+                btrfs_init_workers(&fs_info->scrub_wr_completion_workers,
+                                   "scrubwrc",
+                                   fs_info->thread_pool_size,
+                                   &fs_info->generic_worker);
+                fs_info->scrub_wr_completion_workers.idle_thresh = 2;
+                ret = btrfs_start_workers(
+                                &fs_info->scrub_wr_completion_workers);
+                if (ret)
+                        goto out;
+                btrfs_init_workers(&fs_info->scrub_nocow_workers, "scrubnc", 1,
+                                   &fs_info->generic_worker);
+                ret = btrfs_start_workers(&fs_info->scrub_nocow_workers);
+                if (ret)
+                        goto out;
         }
         ++fs_info->scrub_workers_refcnt;
 out:
@@ -2235,40 +2764,41 @@ out:
         return ret;
 }
 
-static noinline_for_stack void scrub_workers_put(struct btrfs_root *root)
+static noinline_for_stack void scrub_workers_put(struct btrfs_fs_info *fs_info)
 {
-        struct btrfs_fs_info *fs_info = root->fs_info;
-
         mutex_lock(&fs_info->scrub_lock);
-        if (--fs_info->scrub_workers_refcnt == 0)
+        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_root *root, u64 devid, u64 start, u64 end,
-                    struct btrfs_scrub_progress *progress, int readonly)
+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)
 {
-        struct scrub_dev *sdev;
-        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct scrub_ctx *sctx;
         int ret;
         struct btrfs_device *dev;
 
-        if (btrfs_fs_closing(root->fs_info))
+        if (btrfs_fs_closing(fs_info))
                 return -EINVAL;
 
         /*
          * check some assumptions
          */
-        if (root->nodesize != root->leafsize) {
+        if (fs_info->chunk_root->nodesize != fs_info->chunk_root->leafsize) {
                 printk(KERN_ERR
                        "btrfs_scrub: size assumption nodesize == leafsize (%d == %d) fails\n",
-                       root->nodesize, root->leafsize);
+                       fs_info->chunk_root->nodesize,
+                       fs_info->chunk_root->leafsize);
                 return -EINVAL;
         }
 
-        if (root->nodesize > BTRFS_STRIPE_LEN) {
+        if (fs_info->chunk_root->nodesize > BTRFS_STRIPE_LEN) {
                 /*
                  * in this case scrub is unable to calculate the checksum
                  * the way scrub is implemented. Do not handle this
@@ -2276,80 +2806,105 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end,
                  */
                 printk(KERN_ERR
                        "btrfs_scrub: size assumption nodesize <= BTRFS_STRIPE_LEN (%d <= %d) fails\n",
-                       root->nodesize, BTRFS_STRIPE_LEN);
+                       fs_info->chunk_root->nodesize, BTRFS_STRIPE_LEN);
                 return -EINVAL;
         }
 
-        if (root->sectorsize != PAGE_SIZE) {
+        if (fs_info->chunk_root->sectorsize != PAGE_SIZE) {
                 /* not supported for data w/o checksums */
                 printk(KERN_ERR
                        "btrfs_scrub: size assumption sectorsize != PAGE_SIZE (%d != %lld) fails\n",
-                       root->sectorsize, (unsigned long long)PAGE_SIZE);
+                       fs_info->chunk_root->sectorsize,
+                       (unsigned long long)PAGE_SIZE);
+                return -EINVAL;
+        }
+
+        if (fs_info->chunk_root->nodesize >
+            PAGE_SIZE * SCRUB_MAX_PAGES_PER_BLOCK ||
+            fs_info->chunk_root->sectorsize >
+            PAGE_SIZE * SCRUB_MAX_PAGES_PER_BLOCK) {
+                /*
+                 * would exhaust the array bounds of pagev member in
+                 * struct scrub_block
+                 */
+                pr_err("btrfs_scrub: size assumption nodesize and sectorsize <= SCRUB_MAX_PAGES_PER_BLOCK (%d <= %d && %d <= %d) fails\n",
+                       fs_info->chunk_root->nodesize,
+                       SCRUB_MAX_PAGES_PER_BLOCK,
+                       fs_info->chunk_root->sectorsize,
+                       SCRUB_MAX_PAGES_PER_BLOCK);
                 return -EINVAL;
         }
 
-        ret = scrub_workers_get(root);
+        ret = scrub_workers_get(fs_info, is_dev_replace);
         if (ret)
                 return ret;
 
-        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
-        dev = btrfs_find_device(root, devid, NULL, NULL);
-        if (!dev || dev->missing) {
-                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(root);
+        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);
 
-        if (!dev->in_fs_metadata) {
+        if (!dev->in_fs_metadata || dev->is_tgtdev_for_dev_replace) {
                 mutex_unlock(&fs_info->scrub_lock);
-                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(root);
-                return -ENODEV;
+                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+                scrub_workers_put(fs_info);
+                return -EIO;
         }
 
-        if (dev->scrub_device) {
+        btrfs_dev_replace_lock(&fs_info->dev_replace);
+        if (dev->scrub_device ||
+            (!is_dev_replace &&
+             btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))) {
+                btrfs_dev_replace_unlock(&fs_info->dev_replace);
                 mutex_unlock(&fs_info->scrub_lock);
-                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(root);
+                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+                scrub_workers_put(fs_info);
                 return -EINPROGRESS;
         }
-        sdev = scrub_setup_dev(dev);
-        if (IS_ERR(sdev)) {
+        btrfs_dev_replace_unlock(&fs_info->dev_replace);
+        sctx = scrub_setup_ctx(dev, is_dev_replace);
+        if (IS_ERR(sctx)) {
                 mutex_unlock(&fs_info->scrub_lock);
-                mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
-                scrub_workers_put(root);
-                return PTR_ERR(sdev);
+                mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+                scrub_workers_put(fs_info);
+                return PTR_ERR(sctx);
         }
-        sdev->readonly = readonly;
-        dev->scrub_device = sdev;
+        sctx->readonly = readonly;
+        dev->scrub_device = sctx;
 
         atomic_inc(&fs_info->scrubs_running);
         mutex_unlock(&fs_info->scrub_lock);
-        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
 
-        down_read(&fs_info->scrub_super_lock);
-        ret = scrub_supers(sdev);
-        up_read(&fs_info->scrub_super_lock);
+        if (!is_dev_replace) {
+                down_read(&fs_info->scrub_super_lock);
+                ret = scrub_supers(sctx, dev);
+                up_read(&fs_info->scrub_super_lock);
+        }
 
         if (!ret)
-                ret = scrub_enumerate_chunks(sdev, start, end);
+                ret = scrub_enumerate_chunks(sctx, dev, start, end,
+                                             is_dev_replace);
 
-        wait_event(sdev->list_wait, atomic_read(&sdev->in_flight) == 0);
+        wait_event(sctx->list_wait, atomic_read(&sctx->bios_in_flight) == 0);
         atomic_dec(&fs_info->scrubs_running);
         wake_up(&fs_info->scrub_pause_wait);
 
-        wait_event(sdev->list_wait, atomic_read(&sdev->fixup_cnt) == 0);
+        wait_event(sctx->list_wait, atomic_read(&sctx->workers_pending) == 0);
 
         if (progress)
-                memcpy(progress, &sdev->stat, sizeof(*progress));
+                memcpy(progress, &sctx->stat, sizeof(*progress));
 
         mutex_lock(&fs_info->scrub_lock);
         dev->scrub_device = NULL;
         mutex_unlock(&fs_info->scrub_lock);
 
-        scrub_free_dev(sdev);
-        scrub_workers_put(root);
+        scrub_free_ctx(sctx);
+        scrub_workers_put(fs_info);
 
         return ret;
 }
@@ -2389,9 +2944,8 @@ 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)
+int btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)
 {
-
         mutex_lock(&fs_info->scrub_lock);
         if (!atomic_read(&fs_info->scrubs_running)) {
                 mutex_unlock(&fs_info->scrub_lock);
@@ -2411,23 +2965,18 @@ int __btrfs_scrub_cancel(struct btrfs_fs_info *fs_info)
         return 0;
 }
 
-int btrfs_scrub_cancel(struct btrfs_root *root)
+int btrfs_scrub_cancel_dev(struct btrfs_fs_info *fs_info,
+                           struct btrfs_device *dev)
 {
-        return __btrfs_scrub_cancel(root->fs_info);
-}
-
-int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev)
-{
-        struct btrfs_fs_info *fs_info = root->fs_info;
-        struct scrub_dev *sdev;
+        struct scrub_ctx *sctx;
 
         mutex_lock(&fs_info->scrub_lock);
-        sdev = dev->scrub_device;
-        if (!sdev) {
+        sctx = dev->scrub_device;
+        if (!sctx) {
                 mutex_unlock(&fs_info->scrub_lock);
                 return -ENOTCONN;
         }
-        atomic_inc(&sdev->cancel_req);
+        atomic_inc(&sctx->cancel_req);
         while (dev->scrub_device) {
                 mutex_unlock(&fs_info->scrub_lock);
                 wait_event(fs_info->scrub_pause_wait,
@@ -2450,12 +2999,12 @@ int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid)
          * does not go away in cancel_dev. FIXME: find a better solution
          */
         mutex_lock(&fs_info->fs_devices->device_list_mutex);
-        dev = btrfs_find_device(root, devid, NULL, NULL);
+        dev = btrfs_find_device(fs_info, devid, NULL, NULL);
         if (!dev) {
                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
                 return -ENODEV;
         }
-        ret = btrfs_scrub_cancel_dev(root, dev);
+        ret = btrfs_scrub_cancel_dev(fs_info, dev);
         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
 
         return ret;
@@ -2465,15 +3014,284 @@ int btrfs_scrub_progress(struct btrfs_root *root, u64 devid,
                          struct btrfs_scrub_progress *progress)
 {
         struct btrfs_device *dev;
-        struct scrub_dev *sdev = NULL;
+        struct scrub_ctx *sctx = NULL;
 
         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
-        dev = btrfs_find_device(root, devid, NULL, NULL);
+        dev = btrfs_find_device(root->fs_info, devid, NULL, NULL);
         if (dev)
-                sdev = dev->scrub_device;
-        if (sdev)
-                memcpy(progress, &sdev->stat, sizeof(*progress));
+                sctx = dev->scrub_device;
+        if (sctx)
+                memcpy(progress, &sctx->stat, sizeof(*progress));
         mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
 
-        return dev ? (sdev ? 0 : -ENOTCONN) : -ENODEV;
+        return dev ? (sctx ? 0 : -ENOTCONN) : -ENODEV;
+}
+
+static void scrub_remap_extent(struct btrfs_fs_info *fs_info,
+                               u64 extent_logical, u64 extent_len,
+                               u64 *extent_physical,
+                               struct btrfs_device **extent_dev,
+                               int *extent_mirror_num)
+{
+        u64 mapped_length;
+        struct btrfs_bio *bbio = NULL;
+        int ret;
+
+        mapped_length = extent_len;
+        ret = btrfs_map_block(fs_info, READ, extent_logical,
+                              &mapped_length, &bbio, 0);
+        if (ret || !bbio || mapped_length < extent_len ||
+            !bbio->stripes[0].dev->bdev) {
+                kfree(bbio);
+                return;
+        }
+
+        *extent_physical = bbio->stripes[0].physical;
+        *extent_mirror_num = bbio->mirror_num;
+        *extent_dev = bbio->stripes[0].dev;
+        kfree(bbio);
+}
+
+static int scrub_setup_wr_ctx(struct scrub_ctx *sctx,
+                              struct scrub_wr_ctx *wr_ctx,
+                              struct btrfs_fs_info *fs_info,
+                              struct btrfs_device *dev,
+                              int is_dev_replace)
+{
+        WARN_ON(wr_ctx->wr_curr_bio != NULL);
+
+        mutex_init(&wr_ctx->wr_lock);
+        wr_ctx->wr_curr_bio = NULL;
+        if (!is_dev_replace)
+                return 0;
+
+        WARN_ON(!dev->bdev);
+        wr_ctx->pages_per_wr_bio = min_t(int, SCRUB_PAGES_PER_WR_BIO,
+                                         bio_get_nr_vecs(dev->bdev));
+        wr_ctx->tgtdev = dev;
+        atomic_set(&wr_ctx->flush_all_writes, 0);
+        return 0;
+}
+
+static void scrub_free_wr_ctx(struct scrub_wr_ctx *wr_ctx)
+{
+        mutex_lock(&wr_ctx->wr_lock);
+        kfree(wr_ctx->wr_curr_bio);
+        wr_ctx->wr_curr_bio = NULL;
+        mutex_unlock(&wr_ctx->wr_lock);
+}
+
+static int copy_nocow_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
+                            int mirror_num, u64 physical_for_dev_replace)
+{
+        struct scrub_copy_nocow_ctx *nocow_ctx;
+        struct btrfs_fs_info *fs_info = sctx->dev_root->fs_info;
+
+        nocow_ctx = kzalloc(sizeof(*nocow_ctx), GFP_NOFS);
+        if (!nocow_ctx) {
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.malloc_errors++;
+                spin_unlock(&sctx->stat_lock);
+                return -ENOMEM;
+        }
+
+        scrub_pending_trans_workers_inc(sctx);
+
+        nocow_ctx->sctx = sctx;
+        nocow_ctx->logical = logical;
+        nocow_ctx->len = 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;
+        btrfs_queue_worker(&fs_info->scrub_nocow_workers,
+                           &nocow_ctx->work);
+
+        return 0;
+}
+
+static void copy_nocow_pages_worker(struct btrfs_work *work)
+{
+        struct scrub_copy_nocow_ctx *nocow_ctx =
+                container_of(work, struct scrub_copy_nocow_ctx, work);
+        struct scrub_ctx *sctx = nocow_ctx->sctx;
+        u64 logical = nocow_ctx->logical;
+        u64 len = nocow_ctx->len;
+        int mirror_num = nocow_ctx->mirror_num;
+        u64 physical_for_dev_replace = nocow_ctx->physical_for_dev_replace;
+        int ret;
+        struct btrfs_trans_handle *trans = NULL;
+        struct btrfs_fs_info *fs_info;
+        struct btrfs_path *path;
+        struct btrfs_root *root;
+        int not_written = 0;
+
+        fs_info = sctx->dev_root->fs_info;
+        root = fs_info->extent_root;
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.malloc_errors++;
+                spin_unlock(&sctx->stat_lock);
+                not_written = 1;
+                goto out;
+        }
+
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans)) {
+                not_written = 1;
+                goto out;
+        }
+
+        ret = iterate_inodes_from_logical(logical, fs_info, path,
+                                          copy_nocow_pages_for_inode,
+                                          nocow_ctx);
+        if (ret != 0 && ret != -ENOENT) {
+                pr_warn("iterate_inodes_from_logical() failed: log %llu, phys %llu, len %llu, mir %llu, ret %d\n",
+                        (unsigned long long)logical,
+                        (unsigned long long)physical_for_dev_replace,
+                        (unsigned long long)len,
+                        (unsigned long long)mirror_num, ret);
+                not_written = 1;
+                goto out;
+        }
+
+out:
+        if (trans && !IS_ERR(trans))
+                btrfs_end_transaction(trans, root);
+        if (not_written)
+                btrfs_dev_replace_stats_inc(&fs_info->dev_replace.
+                                            num_uncorrectable_read_errors);
+
+        btrfs_free_path(path);
+        kfree(nocow_ctx);
+
+        scrub_pending_trans_workers_dec(sctx);
+}
+
+static int copy_nocow_pages_for_inode(u64 inum, u64 offset, u64 root, void *ctx)
+{
+        unsigned long index;
+        struct scrub_copy_nocow_ctx *nocow_ctx = ctx;
+        int ret = 0;
+        struct btrfs_key key;
+        struct inode *inode = NULL;
+        struct btrfs_root *local_root;
+        u64 physical_for_dev_replace;
+        u64 len;
+        struct btrfs_fs_info *fs_info = nocow_ctx->sctx->dev_root->fs_info;
+
+        key.objectid = root;
+        key.type = BTRFS_ROOT_ITEM_KEY;
+        key.offset = (u64)-1;
+        local_root = btrfs_read_fs_root_no_name(fs_info, &key);
+        if (IS_ERR(local_root))
+                return PTR_ERR(local_root);
+
+        key.type = BTRFS_INODE_ITEM_KEY;
+        key.objectid = inum;
+        key.offset = 0;
+        inode = btrfs_iget(fs_info->sb, &key, local_root, NULL);
+        if (IS_ERR(inode))
+                return PTR_ERR(inode);
+
+        physical_for_dev_replace = nocow_ctx->physical_for_dev_replace;
+        len = nocow_ctx->len;
+        while (len >= PAGE_CACHE_SIZE) {
+                struct page *page = NULL;
+                int ret_sub;
+
+                index = offset >> PAGE_CACHE_SHIFT;
+
+                page = find_or_create_page(inode->i_mapping, index, GFP_NOFS);
+                if (!page) {
+                        pr_err("find_or_create_page() failed\n");
+                        ret = -ENOMEM;
+                        goto next_page;
+                }
+
+                if (PageUptodate(page)) {
+                        if (PageDirty(page))
+                                goto next_page;
+                } else {
+                        ClearPageError(page);
+                        ret_sub = extent_read_full_page(&BTRFS_I(inode)->
+                                                         io_tree,
+                                                        page, btrfs_get_extent,
+                                                        nocow_ctx->mirror_num);
+                        if (ret_sub) {
+                                ret = ret_sub;
+                                goto next_page;
+                        }
+                        wait_on_page_locked(page);
+                        if (!PageUptodate(page)) {
+                                ret = -EIO;
+                                goto next_page;
+                        }
+                }
+                ret_sub = write_page_nocow(nocow_ctx->sctx,
+                                           physical_for_dev_replace, page);
+                if (ret_sub) {
+                        ret = ret_sub;
+                        goto next_page;
+                }
+
+next_page:
+                if (page) {
+                        unlock_page(page);
+                        put_page(page);
+                }
+                offset += PAGE_CACHE_SIZE;
+                physical_for_dev_replace += PAGE_CACHE_SIZE;
+                len -= PAGE_CACHE_SIZE;
+        }
+
+        if (inode)
+                iput(inode);
+        return ret;
+}
+
+static int write_page_nocow(struct scrub_ctx *sctx,
+                            u64 physical_for_dev_replace, struct page *page)
+{
+        struct bio *bio;
+        struct btrfs_device *dev;
+        int ret;
+        DECLARE_COMPLETION_ONSTACK(compl);
+
+        dev = sctx->wr_ctx.tgtdev;
+        if (!dev)
+                return -EIO;
+        if (!dev->bdev) {
+                printk_ratelimited(KERN_WARNING
+                        "btrfs: scrub write_page_nocow(bdev == NULL) is unexpected!\n");
+                return -EIO;
+        }
+        bio = bio_alloc(GFP_NOFS, 1);
+        if (!bio) {
+                spin_lock(&sctx->stat_lock);
+                sctx->stat.malloc_errors++;
+                spin_unlock(&sctx->stat_lock);
+                return -ENOMEM;
+        }
+        bio->bi_private = &compl;
+        bio->bi_end_io = scrub_complete_bio_end_io;
+        bio->bi_size = 0;
+        bio->bi_sector = physical_for_dev_replace >> 9;
+        bio->bi_bdev = dev->bdev;
+        ret = bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);
+        if (ret != PAGE_CACHE_SIZE) {
+leave_with_eio:
+                bio_put(bio);
+                btrfs_dev_stat_inc_and_print(dev, BTRFS_DEV_STAT_WRITE_ERRS);
+                return -EIO;
+        }
+        btrfsic_submit_bio(WRITE_SYNC, bio);
+        wait_for_completion(&compl);
+
+        if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
+                goto leave_with_eio;
+
+        bio_put(bio);
+        return 0;
 }
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index fb5ffe95f869..54454542ad40 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -107,7 +107,6 @@ struct send_ctx {
         int cur_inode_new;
         int cur_inode_new_gen;
         int cur_inode_deleted;
-        int cur_inode_first_ref_orphan;
         u64 cur_inode_size;
         u64 cur_inode_mode;
 
@@ -126,7 +125,15 @@ struct send_ctx {
 
 struct name_cache_entry {
         struct list_head list;
-        struct list_head use_list;
+        /*
+         * radix_tree has only 32bit entries but we need to handle 64bit inums.
+         * We use the lower 32bit of the 64bit inum to store it in the tree. If
+         * more then one inum would fall into the same entry, we use radix_list
+         * to store the additional entries. radix_list is also used to store
+         * entries where two entries have the same inum but different
+         * generations.
+         */
+        struct list_head radix_list;
         u64 ino;
         u64 gen;
         u64 parent_ino;
@@ -328,6 +335,7 @@ out:
         return ret;
 }
 
+#if 0
 static void fs_path_remove(struct fs_path *p)
 {
         BUG_ON(p->reversed);
@@ -335,6 +343,7 @@ static void fs_path_remove(struct fs_path *p)
                 p->end--;
         *p->end = 0;
 }
+#endif
 
 static int fs_path_copy(struct fs_path *p, struct fs_path *from)
 {
@@ -377,7 +386,7 @@ static struct btrfs_path *alloc_path_for_send(void)
         return path;
 }
 
-static int write_buf(struct send_ctx *sctx, const void *buf, u32 len)
+int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off)
 {
         int ret;
         mm_segment_t old_fs;
@@ -387,8 +396,7 @@ static int write_buf(struct send_ctx *sctx, const void *buf, u32 len)
         set_fs(KERNEL_DS);
 
         while (pos < len) {
-                ret = vfs_write(sctx->send_filp, (char *)buf + pos, len - pos,
-                                &sctx->send_off);
+                ret = vfs_write(filp, (char *)buf + pos, len - pos, off);
                 /* TODO handle that correctly */
                 /*if (ret == -ERESTARTSYS) {
                         continue;
@@ -544,7 +552,8 @@ static int send_header(struct send_ctx *sctx)
         strcpy(hdr.magic, BTRFS_SEND_STREAM_MAGIC);
         hdr.version = cpu_to_le32(BTRFS_SEND_STREAM_VERSION);
 
-        return write_buf(sctx, &hdr, sizeof(hdr));
+        return write_buf(sctx->send_filp, &hdr, sizeof(hdr),
+                                        &sctx->send_off);
 }
 
 /*
@@ -581,7 +590,8 @@ static int send_cmd(struct send_ctx *sctx)
         crc = crc32c(0, (unsigned char *)sctx->send_buf, sctx->send_size);
         hdr->crc = cpu_to_le32(crc);
 
-        ret = write_buf(sctx, sctx->send_buf, sctx->send_size);
+        ret = write_buf(sctx->send_filp, sctx->send_buf, sctx->send_size,
+                                        &sctx->send_off);
 
         sctx->total_send_size += sctx->send_size;
         sctx->cmd_send_size[le16_to_cpu(hdr->cmd)] += sctx->send_size;
@@ -687,7 +697,8 @@ out:
  */
 static int get_inode_info(struct btrfs_root *root,
                           u64 ino, u64 *size, u64 *gen,
-                          u64 *mode, u64 *uid, u64 *gid)
+                          u64 *mode, u64 *uid, u64 *gid,
+                          u64 *rdev)
 {
         int ret;
         struct btrfs_inode_item *ii;
@@ -721,6 +732,8 @@ static int get_inode_info(struct btrfs_root *root,
                 *uid = btrfs_inode_uid(path->nodes[0], ii);
         if (gid)
                 *gid = btrfs_inode_gid(path->nodes[0], ii);
+        if (rdev)
+                *rdev = btrfs_inode_rdev(path->nodes[0], ii);
 
 out:
         btrfs_free_path(path);
@@ -732,31 +745,36 @@ typedef int (*iterate_inode_ref_t)(int num, u64 dir, int index,
                                    void *ctx);
 
 /*
- * Helper function to iterate the entries in ONE btrfs_inode_ref.
+ * Helper function to iterate the entries in ONE btrfs_inode_ref or
+ * btrfs_inode_extref.
  * The iterate callback may return a non zero value to stop iteration. This can
  * be a negative value for error codes or 1 to simply stop it.
  *
- * path must point to the INODE_REF when called.
+ * path must point to the INODE_REF or INODE_EXTREF when called.
  */
 static int iterate_inode_ref(struct send_ctx *sctx,
                              struct btrfs_root *root, struct btrfs_path *path,
                              struct btrfs_key *found_key, int resolve,
                              iterate_inode_ref_t iterate, void *ctx)
 {
-        struct extent_buffer *eb;
+        struct extent_buffer *eb = path->nodes[0];
         struct btrfs_item *item;
         struct btrfs_inode_ref *iref;
+        struct btrfs_inode_extref *extref;
         struct btrfs_path *tmp_path;
         struct fs_path *p;
-        u32 cur;
-        u32 len;
+        u32 cur = 0;
         u32 total;
-        int slot;
+        int slot = path->slots[0];
         u32 name_len;
         char *start;
         int ret = 0;
-        int num;
+        int num = 0;
         int index;
+        u64 dir;
+        unsigned long name_off;
+        unsigned long elem_size;
+        unsigned long ptr;
 
         p = fs_path_alloc_reversed(sctx);
         if (!p)
@@ -768,24 +786,40 @@ static int iterate_inode_ref(struct send_ctx *sctx,
                 return -ENOMEM;
         }
 
-        eb = path->nodes[0];
-        slot = path->slots[0];
-        item = btrfs_item_nr(eb, slot);
-        iref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
-        cur = 0;
-        len = 0;
-        total = btrfs_item_size(eb, item);
 
-        num = 0;
+        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);
+                total = btrfs_item_size(eb, item);
+                elem_size = sizeof(*iref);
+        } else {
+                ptr = btrfs_item_ptr_offset(eb, slot);
+                total = btrfs_item_size_nr(eb, slot);
+                elem_size = sizeof(*extref);
+        }
+
         while (cur < total) {
                 fs_path_reset(p);
 
-                name_len = btrfs_inode_ref_name_len(eb, iref);
-                index = btrfs_inode_ref_index(eb, iref);
+                if (found_key->type == BTRFS_INODE_REF_KEY) {
+                        iref = (struct btrfs_inode_ref *)(ptr + cur);
+                        name_len = btrfs_inode_ref_name_len(eb, iref);
+                        name_off = (unsigned long)(iref + 1);
+                        index = btrfs_inode_ref_index(eb, iref);
+                        dir = found_key->offset;
+                } else {
+                        extref = (struct btrfs_inode_extref *)(ptr + cur);
+                        name_len = btrfs_inode_extref_name_len(eb, extref);
+                        name_off = (unsigned long)&extref->name;
+                        index = btrfs_inode_extref_index(eb, extref);
+                        dir = btrfs_inode_extref_parent(eb, extref);
+                }
+
                 if (resolve) {
-                        start = btrfs_iref_to_path(root, tmp_path, iref, eb,
-                                                found_key->offset, p->buf,
-                                                p->buf_len);
+                        start = btrfs_ref_to_path(root, tmp_path, name_len,
+                                                  name_off, eb, dir,
+                                                  p->buf, p->buf_len);
                         if (IS_ERR(start)) {
                                 ret = PTR_ERR(start);
                                 goto out;
@@ -796,9 +830,10 @@ static int iterate_inode_ref(struct send_ctx *sctx,
                                                 p->buf_len + p->buf - start);
                                 if (ret < 0)
                                         goto out;
-                                start = btrfs_iref_to_path(root, tmp_path, iref,
-                                                eb, found_key->offset, p->buf,
-                                                p->buf_len);
+                                start = btrfs_ref_to_path(root, tmp_path,
+                                                          name_len, name_off,
+                                                          eb, dir,
+                                                          p->buf, p->buf_len);
                                 if (IS_ERR(start)) {
                                         ret = PTR_ERR(start);
                                         goto out;
@@ -807,21 +842,16 @@ static int iterate_inode_ref(struct send_ctx *sctx,
                         }
                         p->start = start;
                 } else {
-                        ret = fs_path_add_from_extent_buffer(p, eb,
-                                        (unsigned long)(iref + 1), name_len);
+                        ret = fs_path_add_from_extent_buffer(p, eb, name_off,
+                                                             name_len);
                         if (ret < 0)
                                 goto out;
                 }
 
-
-                len = sizeof(*iref) + name_len;
-                iref = (struct btrfs_inode_ref *)((char *)iref + len);
-                cur += len;
-
-                ret = iterate(num, found_key->offset, index, p, ctx);
+                cur += elem_size + name_len;
+                ret = iterate(num, dir, index, p, ctx);
                 if (ret)
                         goto out;
-
                 num++;
         }
 
@@ -852,7 +882,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
         struct extent_buffer *eb;
         struct btrfs_item *item;
         struct btrfs_dir_item *di;
-        struct btrfs_path *tmp_path = NULL;
         struct btrfs_key di_key;
         char *buf = NULL;
         char *buf2 = NULL;
@@ -874,12 +903,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
                 goto out;
         }
 
-        tmp_path = alloc_path_for_send();
-        if (!tmp_path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
         eb = path->nodes[0];
         slot = path->slots[0];
         item = btrfs_item_nr(eb, slot);
@@ -941,7 +964,6 @@ static int iterate_dir_item(struct send_ctx *sctx,
         }
 
 out:
-        btrfs_free_path(tmp_path);
         if (buf_virtual)
                 vfree(buf);
         else
@@ -993,7 +1015,8 @@ static int get_inode_path(struct send_ctx *sctx, struct btrfs_root *root,
         }
         btrfs_item_key_to_cpu(p->nodes[0], &found_key, p->slots[0]);
         if (found_key.objectid != ino ||
-                found_key.type != BTRFS_INODE_REF_KEY) {
+            (found_key.type != BTRFS_INODE_REF_KEY &&
+             found_key.type != BTRFS_INODE_EXTREF_KEY)) {
                 ret = -ENOENT;
                 goto out;
         }
@@ -1026,12 +1049,12 @@ struct backref_ctx {
         u64 extent_len;
 
         /* Just to check for bugs in backref resolving */
-        int found_in_send_root;
+        int found_itself;
 };
 
 static int __clone_root_cmp_bsearch(const void *key, const void *elt)
 {
-        u64 root = (u64)key;
+        u64 root = (u64)(uintptr_t)key;
         struct clone_root *cr = (struct clone_root *)elt;
 
         if (root < cr->root->objectid)
@@ -1055,6 +1078,7 @@ static int __clone_root_cmp_sort(const void *e1, const void *e2)
 
 /*
  * Called for every backref that is found for the current extent.
+ * Results are collected in sctx->clone_roots->ino/offset/found_refs
  */
 static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
 {
@@ -1064,7 +1088,7 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
         u64 i_size;
 
         /* First check if the root is in the list of accepted clone sources */
-        found = bsearch((void *)root, bctx->sctx->clone_roots,
+        found = bsearch((void *)(uintptr_t)root, bctx->sctx->clone_roots,
                         bctx->sctx->clone_roots_cnt,
                         sizeof(struct clone_root),
                         __clone_root_cmp_bsearch);
@@ -1074,14 +1098,15 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
         if (found->root == bctx->sctx->send_root &&
             ino == bctx->cur_objectid &&
             offset == bctx->cur_offset) {
-                bctx->found_in_send_root = 1;
+                bctx->found_itself = 1;
         }
 
         /*
-         * There are inodes that have extents that lie behind it's i_size. Don't
+         * There are inodes that have extents that lie behind its i_size. Don't
          * accept clones from these extents.
          */
-        ret = get_inode_info(found->root, ino, &i_size, NULL, NULL, NULL, NULL);
+        ret = get_inode_info(found->root, ino, &i_size, NULL, NULL, NULL, NULL,
+                        NULL);
         if (ret < 0)
                 return ret;
 
@@ -1101,16 +1126,12 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
                  */
                 if (ino >= bctx->cur_objectid)
                         return 0;
-                /*if (ino > ctx->cur_objectid)
+#if 0
+                if (ino > bctx->cur_objectid)
                         return 0;
-                if (offset + ctx->extent_len > ctx->cur_offset)
-                        return 0;*/
-
-                bctx->found++;
-                found->found_refs++;
-                found->ino = ino;
-                found->offset = offset;
-                return 0;
+                if (offset + bctx->extent_len > bctx->cur_offset)
+                        return 0;
+#endif
         }
 
         bctx->found++;
@@ -1130,6 +1151,12 @@ static int __iterate_backrefs(u64 ino, u64 offset, u64 root, void *ctx_)
 }
 
 /*
+ * Given an inode, offset and extent item, it finds a good clone for a clone
+ * instruction. Returns -ENOENT when none could be found. The function makes
+ * sure that the returned clone is usable at the point where sending is at the
+ * moment. This means, that no clones are accepted which lie behind the current
+ * inode+offset.
+ *
  * path must point to the extent item when called.
  */
 static int find_extent_clone(struct send_ctx *sctx,
@@ -1141,20 +1168,29 @@ static int find_extent_clone(struct send_ctx *sctx,
         int ret;
         int extent_type;
         u64 logical;
+        u64 disk_byte;
         u64 num_bytes;
         u64 extent_item_pos;
+        u64 flags = 0;
         struct btrfs_file_extent_item *fi;
         struct extent_buffer *eb = path->nodes[0];
-        struct backref_ctx backref_ctx;
+        struct backref_ctx *backref_ctx = NULL;
         struct clone_root *cur_clone_root;
         struct btrfs_key found_key;
         struct btrfs_path *tmp_path;
+        int compressed;
         u32 i;
 
         tmp_path = alloc_path_for_send();
         if (!tmp_path)
                 return -ENOMEM;
 
+        backref_ctx = kmalloc(sizeof(*backref_ctx), GFP_NOFS);
+        if (!backref_ctx) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
         if (data_offset >= ino_size) {
                 /*
                  * There may be extents that lie behind the file's size.
@@ -1172,22 +1208,23 @@ static int find_extent_clone(struct send_ctx *sctx,
                 ret = -ENOENT;
                 goto out;
         }
+        compressed = btrfs_file_extent_compression(eb, fi);
 
         num_bytes = btrfs_file_extent_num_bytes(eb, fi);
-        logical = btrfs_file_extent_disk_bytenr(eb, fi);
-        if (logical == 0) {
+        disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+        if (disk_byte == 0) {
                 ret = -ENOENT;
                 goto out;
         }
-        logical += btrfs_file_extent_offset(eb, fi);
+        logical = disk_byte + btrfs_file_extent_offset(eb, fi);
 
-        ret = extent_from_logical(sctx->send_root->fs_info,
-                        logical, tmp_path, &found_key);
+        ret = extent_from_logical(sctx->send_root->fs_info, disk_byte, tmp_path,
+                                  &found_key, &flags);
         btrfs_release_path(tmp_path);
 
         if (ret < 0)
                 goto out;
-        if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
+        if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
                 ret = -EIO;
                 goto out;
         }
@@ -1202,12 +1239,12 @@ static int find_extent_clone(struct send_ctx *sctx,
                 cur_clone_root->found_refs = 0;
         }
 
-        backref_ctx.sctx = sctx;
-        backref_ctx.found = 0;
-        backref_ctx.cur_objectid = ino;
-        backref_ctx.cur_offset = data_offset;
-        backref_ctx.found_in_send_root = 0;
-        backref_ctx.extent_len = num_bytes;
+        backref_ctx->sctx = sctx;
+        backref_ctx->found = 0;
+        backref_ctx->cur_objectid = ino;
+        backref_ctx->cur_offset = data_offset;
+        backref_ctx->found_itself = 0;
+        backref_ctx->extent_len = num_bytes;
 
         /*
          * The last extent of a file may be too large due to page alignment.
@@ -1215,25 +1252,31 @@ static int find_extent_clone(struct send_ctx *sctx,
          * __iterate_backrefs work.
          */
         if (data_offset + num_bytes >= ino_size)
-                backref_ctx.extent_len = ino_size - data_offset;
+                backref_ctx->extent_len = ino_size - data_offset;
 
         /*
          * Now collect all backrefs.
          */
+        if (compressed == BTRFS_COMPRESS_NONE)
+                extent_item_pos = logical - found_key.objectid;
+        else
+                extent_item_pos = 0;
+
         extent_item_pos = logical - found_key.objectid;
         ret = iterate_extent_inodes(sctx->send_root->fs_info,
                                         found_key.objectid, extent_item_pos, 1,
-                                        __iterate_backrefs, &backref_ctx);
+                                        __iterate_backrefs, backref_ctx);
+
         if (ret < 0)
                 goto out;
 
-        if (!backref_ctx.found_in_send_root) {
+        if (!backref_ctx->found_itself) {
                 /* found a bug in backref code? */
                 ret = -EIO;
                 printk(KERN_ERR "btrfs: ERROR did not find backref in "
                                 "send_root. inode=%llu, offset=%llu, "
-                                "logical=%llu\n",
-                                ino, data_offset, logical);
+                                "disk_byte=%llu found extent=%llu\n",
+                                ino, data_offset, disk_byte, found_key.objectid);
                 goto out;
         }
 
@@ -1242,7 +1285,7 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
                 "num_bytes=%llu, logical=%llu\n",
                 data_offset, ino, num_bytes, logical);
 
-        if (!backref_ctx.found)
+        if (!backref_ctx->found)
                 verbose_printk("btrfs:    no clones found\n");
 
         cur_clone_root = NULL;
@@ -1253,7 +1296,6 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
                         else if (sctx->clone_roots[i].root == sctx->send_root)
                                 /* prefer clones from send_root over others */
                                 cur_clone_root = sctx->clone_roots + i;
-                        break;
                 }
 
         }
@@ -1267,6 +1309,7 @@ verbose_printk(KERN_DEBUG "btrfs: find_extent_clone: data_offset=%llu, "
 
 out:
         btrfs_free_path(tmp_path);
+        kfree(backref_ctx);
         return ret;
 }
 
@@ -1307,8 +1350,6 @@ static int read_symlink(struct send_ctx *sctx,
         len = btrfs_file_extent_inline_len(path->nodes[0], ei);
 
         ret = fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
-        if (ret < 0)
-                goto out;
 
 out:
         btrfs_free_path(path);
@@ -1404,7 +1445,7 @@ static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
         u64 right_gen;
 
         ret = get_inode_info(sctx->send_root, ino, NULL, &left_gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0 && ret != -ENOENT)
                 goto out;
         left_ret = ret;
@@ -1413,16 +1454,16 @@ static int get_cur_inode_state(struct send_ctx *sctx, u64 ino, u64 gen)
                 right_ret = -ENOENT;
         } else {
                 ret = get_inode_info(sctx->parent_root, ino, NULL, &right_gen,
-                                NULL, NULL, NULL);
+                                NULL, NULL, NULL, NULL);
                 if (ret < 0 && ret != -ENOENT)
                         goto out;
                 right_ret = ret;
         }
 
         if (!left_ret && !right_ret) {
-                if (left_gen == gen && right_gen == gen)
+                if (left_gen == gen && right_gen == gen) {
                         ret = inode_state_no_change;
-                else if (left_gen == gen) {
+                } else if (left_gen == gen) {
                         if (ino < sctx->send_progress)
                                 ret = inode_state_did_create;
                         else
@@ -1516,6 +1557,10 @@ out:
         return ret;
 }
 
+/*
+ * Looks up the first btrfs_inode_ref of a given ino. It returns the parent dir,
+ * generation of the parent dir and the name of the dir entry.
+ */
 static int get_first_ref(struct send_ctx *sctx,
                          struct btrfs_root *root, u64 ino,
                          u64 *dir, u64 *dir_gen, struct fs_path *name)
@@ -1524,8 +1569,8 @@ static int get_first_ref(struct send_ctx *sctx,
         struct btrfs_key key;
         struct btrfs_key found_key;
         struct btrfs_path *path;
-        struct btrfs_inode_ref *iref;
         int len;
+        u64 parent_dir;
 
         path = alloc_path_for_send();
         if (!path)
@@ -1541,27 +1586,41 @@ static int get_first_ref(struct send_ctx *sctx,
         if (!ret)
                 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
                                 path->slots[0]);
-        if (ret || found_key.objectid != key.objectid ||
-            found_key.type != key.type) {
+        if (ret || found_key.objectid != ino ||
+            (found_key.type != BTRFS_INODE_REF_KEY &&
+             found_key.type != BTRFS_INODE_EXTREF_KEY)) {
                 ret = -ENOENT;
                 goto out;
         }
 
-        iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
-                        struct btrfs_inode_ref);
-        len = btrfs_inode_ref_name_len(path->nodes[0], iref);
-        ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
-                        (unsigned long)(iref + 1), len);
+        if (key.type == BTRFS_INODE_REF_KEY) {
+                struct btrfs_inode_ref *iref;
+                iref = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                                      struct btrfs_inode_ref);
+                len = btrfs_inode_ref_name_len(path->nodes[0], iref);
+                ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
+                                                     (unsigned long)(iref + 1),
+                                                     len);
+                parent_dir = found_key.offset;
+        } else {
+                struct btrfs_inode_extref *extref;
+                extref = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                                        struct btrfs_inode_extref);
+                len = btrfs_inode_extref_name_len(path->nodes[0], extref);
+                ret = fs_path_add_from_extent_buffer(name, path->nodes[0],
+                                        (unsigned long)&extref->name, len);
+                parent_dir = btrfs_inode_extref_parent(path->nodes[0], extref);
+        }
         if (ret < 0)
                 goto out;
         btrfs_release_path(path);
 
-        ret = get_inode_info(root, found_key.offset, NULL, dir_gen, NULL, NULL,
-                        NULL);
+        ret = get_inode_info(root, parent_dir, NULL, dir_gen, NULL, NULL,
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
-        *dir = found_key.offset;
+        *dir = parent_dir;
 
 out:
         btrfs_free_path(path);
@@ -1586,22 +1645,28 @@ static int is_first_ref(struct send_ctx *sctx,
         if (ret < 0)
                 goto out;
 
-        if (name_len != fs_path_len(tmp_name)) {
+        if (dir != tmp_dir || name_len != fs_path_len(tmp_name)) {
                 ret = 0;
                 goto out;
         }
 
-        ret = memcmp(tmp_name->start, name, name_len);
-        if (ret)
-                ret = 0;
-        else
-                ret = 1;
+        ret = !memcmp(tmp_name->start, name, name_len);
 
 out:
         fs_path_free(sctx, tmp_name);
         return ret;
 }
 
+/*
+ * Used by process_recorded_refs to determine if a new ref would overwrite an
+ * already existing ref. In case it detects an overwrite, it returns the
+ * inode/gen in who_ino/who_gen.
+ * When an overwrite is detected, process_recorded_refs does proper orphanizing
+ * to make sure later references to the overwritten inode are possible.
+ * Orphanizing is however only required for the first ref of an inode.
+ * process_recorded_refs does an additional is_first_ref check to see if
+ * orphanizing is really required.
+ */
 static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
                               const char *name, int name_len,
                               u64 *who_ino, u64 *who_gen)
@@ -1626,9 +1691,14 @@ static int will_overwrite_ref(struct send_ctx *sctx, u64 dir, u64 dir_gen,
                 goto out;
         }
 
+        /*
+         * Check if the overwritten ref was already processed. If yes, the ref
+         * was already unlinked/moved, so we can safely assume that we will not
+         * overwrite anything at this point in time.
+         */
         if (other_inode > sctx->send_progress) {
                 ret = get_inode_info(sctx->parent_root, other_inode, NULL,
-                                who_gen, NULL, NULL, NULL);
+                                who_gen, NULL, NULL, NULL, NULL);
                 if (ret < 0)
                         goto out;
 
@@ -1642,6 +1712,13 @@ out:
         return ret;
 }
 
+/*
+ * Checks if the ref was overwritten by an already processed inode. This is
+ * used by __get_cur_name_and_parent to find out if the ref was orphanized and
+ * thus the orphan name needs be used.
+ * process_recorded_refs also uses it to avoid unlinking of refs that were
+ * overwritten.
+ */
 static int did_overwrite_ref(struct send_ctx *sctx,
                             u64 dir, u64 dir_gen,
                             u64 ino, u64 ino_gen,
@@ -1671,7 +1748,7 @@ static int did_overwrite_ref(struct send_ctx *sctx,
         }
 
         ret = get_inode_info(sctx->send_root, ow_inode, NULL, &gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -1690,6 +1767,11 @@ out:
         return ret;
 }
 
+/*
+ * Same as did_overwrite_ref, but also checks if it is the first ref of an inode
+ * that got overwritten. This is used by process_recorded_refs to determine
+ * if it has to use the path as returned by get_cur_path or the orphan name.
+ */
 static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
 {
         int ret = 0;
@@ -1710,39 +1792,40 @@ static int did_overwrite_first_ref(struct send_ctx *sctx, u64 ino, u64 gen)
 
         ret = did_overwrite_ref(sctx, dir, dir_gen, ino, gen,
                         name->start, fs_path_len(name));
-        if (ret < 0)
-                goto out;
 
 out:
         fs_path_free(sctx, name);
         return ret;
 }
 
+/*
+ * Insert a name cache entry. On 32bit kernels the radix tree index is 32bit,
+ * so we need to do some special handling in case we have clashes. This function
+ * takes care of this with the help of name_cache_entry::radix_list.
+ * In case of error, nce is kfreed.
+ */
 static int name_cache_insert(struct send_ctx *sctx,
                              struct name_cache_entry *nce)
 {
         int ret = 0;
-        struct name_cache_entry **ncea;
-
-        ncea = radix_tree_lookup(&sctx->name_cache, nce->ino);
-        if (ncea) {
-                if (!ncea[0])
-                        ncea[0] = nce;
-                else if (!ncea[1])
-                        ncea[1] = nce;
-                else
-                        BUG();
-        } else {
-                ncea = kmalloc(sizeof(void *) * 2, GFP_NOFS);
-                if (!ncea)
+        struct list_head *nce_head;
+
+        nce_head = radix_tree_lookup(&sctx->name_cache,
+                        (unsigned long)nce->ino);
+        if (!nce_head) {
+                nce_head = kmalloc(sizeof(*nce_head), GFP_NOFS);
+                if (!nce_head)
                         return -ENOMEM;
+                INIT_LIST_HEAD(nce_head);
 
-                ncea[0] = nce;
-                ncea[1] = NULL;
-                ret = radix_tree_insert(&sctx->name_cache, nce->ino, ncea);
-                if (ret < 0)
+                ret = radix_tree_insert(&sctx->name_cache, nce->ino, nce_head);
+                if (ret < 0) {
+                        kfree(nce_head);
+                        kfree(nce);
                         return ret;
+                }
         }
+        list_add_tail(&nce->radix_list, nce_head);
         list_add_tail(&nce->list, &sctx->name_cache_list);
         sctx->name_cache_size++;
 
@@ -1752,50 +1835,52 @@ static int name_cache_insert(struct send_ctx *sctx,
 static void name_cache_delete(struct send_ctx *sctx,
                               struct name_cache_entry *nce)
 {
-        struct name_cache_entry **ncea;
-
-        ncea = radix_tree_lookup(&sctx->name_cache, nce->ino);
-        BUG_ON(!ncea);
-
-        if (ncea[0] == nce)
-                ncea[0] = NULL;
-        else if (ncea[1] == nce)
-                ncea[1] = NULL;
-        else
-                BUG();
+        struct list_head *nce_head;
 
-        if (!ncea[0] && !ncea[1]) {
-                radix_tree_delete(&sctx->name_cache, nce->ino);
-                kfree(ncea);
-        }
+        nce_head = radix_tree_lookup(&sctx->name_cache,
+                        (unsigned long)nce->ino);
+        BUG_ON(!nce_head);
 
+        list_del(&nce->radix_list);
         list_del(&nce->list);
-
         sctx->name_cache_size--;
+
+        if (list_empty(nce_head)) {
+                radix_tree_delete(&sctx->name_cache, (unsigned long)nce->ino);
+                kfree(nce_head);
+        }
 }
 
 static struct name_cache_entry *name_cache_search(struct send_ctx *sctx,
                                                     u64 ino, u64 gen)
 {
-        struct name_cache_entry **ncea;
+        struct list_head *nce_head;
+        struct name_cache_entry *cur;
 
-        ncea = radix_tree_lookup(&sctx->name_cache, ino);
-        if (!ncea)
+        nce_head = radix_tree_lookup(&sctx->name_cache, (unsigned long)ino);
+        if (!nce_head)
                 return NULL;
 
-        if (ncea[0] && ncea[0]->gen == gen)
-                return ncea[0];
-        else if (ncea[1] && ncea[1]->gen == gen)
-                return ncea[1];
+        list_for_each_entry(cur, nce_head, radix_list) {
+                if (cur->ino == ino && cur->gen == gen)
+                        return cur;
+        }
         return NULL;
 }
 
+/*
+ * Removes the entry from the list and adds it back to the end. This marks the
+ * entry as recently used so that name_cache_clean_unused does not remove it.
+ */
 static void name_cache_used(struct send_ctx *sctx, struct name_cache_entry *nce)
 {
         list_del(&nce->list);
         list_add_tail(&nce->list, &sctx->name_cache_list);
 }
 
+/*
+ * Remove some entries from the beginning of name_cache_list.
+ */
 static void name_cache_clean_unused(struct send_ctx *sctx)
 {
         struct name_cache_entry *nce;
@@ -1814,13 +1899,23 @@ static void name_cache_clean_unused(struct send_ctx *sctx)
 static void name_cache_free(struct send_ctx *sctx)
 {
         struct name_cache_entry *nce;
-        struct name_cache_entry *tmp;
 
-        list_for_each_entry_safe(nce, tmp, &sctx->name_cache_list, list) {
+        while (!list_empty(&sctx->name_cache_list)) {
+                nce = list_entry(sctx->name_cache_list.next,
+                                struct name_cache_entry, list);
                 name_cache_delete(sctx, nce);
+                kfree(nce);
         }
 }
 
+/*
+ * Used by get_cur_path for each ref up to the root.
+ * Returns 0 if it succeeded.
+ * Returns 1 if the inode is not existent or got overwritten. In that case, the
+ * name is an orphan name. This instructs get_cur_path to stop iterating. If 1
+ * is returned, parent_ino/parent_gen are not guaranteed to be valid.
+ * Returns <0 in case of error.
+ */
 static int __get_cur_name_and_parent(struct send_ctx *sctx,
                                      u64 ino, u64 gen,
                                      u64 *parent_ino,
@@ -1832,6 +1927,11 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         struct btrfs_path *path = NULL;
         struct name_cache_entry *nce = NULL;
 
+        /*
+         * First check if we already did a call to this function with the same
+         * ino/gen. If yes, check if the cache entry is still up-to-date. If yes
+         * return the cached result.
+         */
         nce = name_cache_search(sctx, ino, gen);
         if (nce) {
                 if (ino < sctx->send_progress && nce->need_later_update) {
@@ -1854,6 +1954,11 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         if (!path)
                 return -ENOMEM;
 
+        /*
+         * If the inode is not existent yet, add the orphan name and return 1.
+         * This should only happen for the parent dir that we determine in
+         * __record_new_ref
+         */
         ret = is_inode_existent(sctx, ino, gen);
         if (ret < 0)
                 goto out;
@@ -1866,6 +1971,10 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
                 goto out_cache;
         }
 
+        /*
+         * Depending on whether the inode was already processed or not, use
+         * send_root or parent_root for ref lookup.
+         */
         if (ino < sctx->send_progress)
                 ret = get_first_ref(sctx, sctx->send_root, ino,
                                 parent_ino, parent_gen, dest);
@@ -1875,6 +1984,10 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         if (ret < 0)
                 goto out;
 
+        /*
+         * Check if the ref was overwritten by an inode's ref that was processed
+         * earlier. If yes, treat as orphan and return 1.
+         */
         ret = did_overwrite_ref(sctx, *parent_ino, *parent_gen, ino, gen,
                         dest->start, dest->end - dest->start);
         if (ret < 0)
@@ -1888,6 +2001,9 @@ static int __get_cur_name_and_parent(struct send_ctx *sctx,
         }
 
 out_cache:
+        /*
+         * Store the result of the lookup in the name cache.
+         */
         nce = kmalloc(sizeof(*nce) + fs_path_len(dest) + 1, GFP_NOFS);
         if (!nce) {
                 ret = -ENOMEM;
@@ -1901,7 +2017,6 @@ out_cache:
         nce->name_len = fs_path_len(dest);
         nce->ret = ret;
         strcpy(nce->name, dest->start);
-        memset(&nce->use_list, 0, sizeof(nce->use_list));
 
         if (ino < sctx->send_progress)
                 nce->need_later_update = 0;
@@ -2107,9 +2222,6 @@ static int send_subvol_begin(struct send_ctx *sctx)
         read_extent_buffer(leaf, name, (unsigned long)(ref + 1), namelen);
         btrfs_release_path(path);
 
-        if (ret < 0)
-                goto out;
-
         if (parent_root) {
                 ret = begin_cmd(sctx, BTRFS_SEND_C_SNAPSHOT);
                 if (ret < 0)
@@ -2276,7 +2388,7 @@ verbose_printk("btrfs: send_utimes %llu\n", ino);
                         btrfs_inode_mtime(ii));
         TLV_PUT_BTRFS_TIMESPEC(sctx, BTRFS_SEND_A_CTIME, eb,
                         btrfs_inode_ctime(ii));
-        /* TODO otime? */
+        /* TODO Add otime support when the otime patches get into upstream */
 
         ret = send_cmd(sctx);
 
@@ -2292,39 +2404,39 @@ out:
  * a valid path yet because we did not process the refs yet. So, the inode
  * is created as orphan.
  */
-static int send_create_inode(struct send_ctx *sctx, struct btrfs_path *path,
-                             struct btrfs_key *key)
+static int send_create_inode(struct send_ctx *sctx, u64 ino)
 {
         int ret = 0;
-        struct extent_buffer *eb = path->nodes[0];
-        struct btrfs_inode_item *ii;
         struct fs_path *p;
-        int slot = path->slots[0];
         int cmd;
+        u64 gen;
         u64 mode;
+        u64 rdev;
 
-verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
+verbose_printk("btrfs: send_create_inode %llu\n", ino);
 
         p = fs_path_alloc(sctx);
         if (!p)
                 return -ENOMEM;
 
-        ii = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
-        mode = btrfs_inode_mode(eb, ii);
+        ret = get_inode_info(sctx->send_root, ino, NULL, &gen, &mode, NULL,
+                        NULL, &rdev);
+        if (ret < 0)
+                goto out;
 
-        if (S_ISREG(mode))
+        if (S_ISREG(mode)) {
                 cmd = BTRFS_SEND_C_MKFILE;
-        else if (S_ISDIR(mode))
+        } else if (S_ISDIR(mode)) {
                 cmd = BTRFS_SEND_C_MKDIR;
-        else if (S_ISLNK(mode))
+        } else if (S_ISLNK(mode)) {
                 cmd = BTRFS_SEND_C_SYMLINK;
-        else if (S_ISCHR(mode) || S_ISBLK(mode))
+        } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
                 cmd = BTRFS_SEND_C_MKNOD;
-        else if (S_ISFIFO(mode))
+        } else if (S_ISFIFO(mode)) {
                 cmd = BTRFS_SEND_C_MKFIFO;
-        else if (S_ISSOCK(mode))
+        } else if (S_ISSOCK(mode)) {
                 cmd = BTRFS_SEND_C_MKSOCK;
-        else {
+        } else {
                 printk(KERN_WARNING "btrfs: unexpected inode type %o",
                                 (int)(mode & S_IFMT));
                 ret = -ENOTSUPP;
@@ -2335,22 +2447,23 @@ verbose_printk("btrfs: send_create_inode %llu\n", sctx->cur_ino);
         if (ret < 0)
                 goto out;
 
-        ret = gen_unique_name(sctx, sctx->cur_ino, sctx->cur_inode_gen, p);
+        ret = gen_unique_name(sctx, ino, gen, p);
         if (ret < 0)
                 goto out;
 
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
-        TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, sctx->cur_ino);
+        TLV_PUT_U64(sctx, BTRFS_SEND_A_INO, ino);
 
         if (S_ISLNK(mode)) {
                 fs_path_reset(p);
-                ret = read_symlink(sctx, sctx->send_root, sctx->cur_ino, p);
+                ret = read_symlink(sctx, sctx->send_root, ino, p);
                 if (ret < 0)
                         goto out;
                 TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH_LINK, p);
         } else if (S_ISCHR(mode) || S_ISBLK(mode) ||
                    S_ISFIFO(mode) || S_ISSOCK(mode)) {
-                TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, btrfs_inode_rdev(eb, ii));
+                TLV_PUT_U64(sctx, BTRFS_SEND_A_RDEV, new_encode_dev(rdev));
+                TLV_PUT_U64(sctx, BTRFS_SEND_A_MODE, mode);
         }
 
         ret = send_cmd(sctx);
@@ -2364,6 +2477,92 @@ out:
         return ret;
 }
 
+/*
+ * We need some special handling for inodes that get processed before the parent
+ * directory got created. See process_recorded_refs for details.
+ * This function does the check if we already created the dir out of order.
+ */
+static int did_create_dir(struct send_ctx *sctx, u64 dir)
+{
+        int ret = 0;
+        struct btrfs_path *path = NULL;
+        struct btrfs_key key;
+        struct btrfs_key found_key;
+        struct btrfs_key di_key;
+        struct extent_buffer *eb;
+        struct btrfs_dir_item *di;
+        int slot;
+
+        path = alloc_path_for_send();
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        key.objectid = dir;
+        key.type = BTRFS_DIR_INDEX_KEY;
+        key.offset = 0;
+        while (1) {
+                ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
+                                1, 0);
+                if (ret < 0)
+                        goto out;
+                if (!ret) {
+                        eb = path->nodes[0];
+                        slot = path->slots[0];
+                        btrfs_item_key_to_cpu(eb, &found_key, slot);
+                }
+                if (ret || found_key.objectid != key.objectid ||
+                    found_key.type != key.type) {
+                        ret = 0;
+                        goto out;
+                }
+
+                di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
+                btrfs_dir_item_key_to_cpu(eb, di, &di_key);
+
+                if (di_key.objectid < sctx->send_progress) {
+                        ret = 1;
+                        goto out;
+                }
+
+                key.offset = found_key.offset + 1;
+                btrfs_release_path(path);
+        }
+
+out:
+        btrfs_free_path(path);
+        return ret;
+}
+
+/*
+ * Only creates the inode if it is:
+ * 1. Not a directory
+ * 2. Or a directory which was not created already due to out of order
+ *    directories. See did_create_dir and process_recorded_refs for details.
+ */
+static int send_create_inode_if_needed(struct send_ctx *sctx)
+{
+        int ret;
+
+        if (S_ISDIR(sctx->cur_inode_mode)) {
+                ret = did_create_dir(sctx, sctx->cur_ino);
+                if (ret < 0)
+                        goto out;
+                if (ret) {
+                        ret = 0;
+                        goto out;
+                }
+        }
+
+        ret = send_create_inode(sctx, sctx->cur_ino);
+        if (ret < 0)
+                goto out;
+
+out:
+        return ret;
+}
+
 struct recorded_ref {
         struct list_head list;
         char *dir_path;
@@ -2416,13 +2615,13 @@ static int record_ref(struct list_head *head, u64 dir,
 static void __free_recorded_refs(struct send_ctx *sctx, struct list_head *head)
 {
         struct recorded_ref *cur;
-        struct recorded_ref *tmp;
 
-        list_for_each_entry_safe(cur, tmp, head, list) {
+        while (!list_empty(head)) {
+                cur = list_entry(head->next, struct recorded_ref, list);
                 fs_path_free(sctx, cur->full_path);
+                list_del(&cur->list);
                 kfree(cur);
         }
-        INIT_LIST_HEAD(head);
 }
 
 static void free_recorded_refs(struct send_ctx *sctx)
@@ -2432,7 +2631,7 @@ static void free_recorded_refs(struct send_ctx *sctx)
 }
 
 /*
- * Renames/moves a file/dir to it's orphan name. Used when the first
+ * Renames/moves a file/dir to its orphan name. Used when the first
  * ref of an unprocessed inode gets overwritten and for all non empty
  * directories.
  */
@@ -2472,6 +2671,12 @@ static int can_rmdir(struct send_ctx *sctx, u64 dir, u64 send_progress)
         struct btrfs_key loc;
         struct btrfs_dir_item *di;
 
+        /*
+         * Don't try to rmdir the top/root subvolume dir.
+         */
+        if (dir == BTRFS_FIRST_FREE_OBJECTID)
+                return 0;
+
         path = alloc_path_for_send();
         if (!path)
                 return -ENOMEM;
@@ -2513,160 +2718,6 @@ out:
         return ret;
 }
 
-struct finish_unordered_dir_ctx {
-        struct send_ctx *sctx;
-        struct fs_path *cur_path;
-        struct fs_path *dir_path;
-        u64 dir_ino;
-        int need_delete;
-        int delete_pass;
-};
-
-int __finish_unordered_dir(int num, struct btrfs_key *di_key,
-                           const char *name, int name_len,
-                           const char *data, int data_len,
-                           u8 type, void *ctx)
-{
-        int ret = 0;
-        struct finish_unordered_dir_ctx *fctx = ctx;
-        struct send_ctx *sctx = fctx->sctx;
-        u64 di_gen;
-        u64 di_mode;
-        int is_orphan = 0;
-
-        if (di_key->objectid >= fctx->dir_ino)
-                goto out;
-
-        fs_path_reset(fctx->cur_path);
-
-        ret = get_inode_info(sctx->send_root, di_key->objectid,
-                        NULL, &di_gen, &di_mode, NULL, NULL);
-        if (ret < 0)
-                goto out;
-
-        ret = is_first_ref(sctx, sctx->send_root, di_key->objectid,
-                        fctx->dir_ino, name, name_len);
-        if (ret < 0)
-                goto out;
-        if (ret) {
-                is_orphan = 1;
-                ret = gen_unique_name(sctx, di_key->objectid, di_gen,
-                                fctx->cur_path);
-        } else {
-                ret = get_cur_path(sctx, di_key->objectid, di_gen,
-                                fctx->cur_path);
-        }
-        if (ret < 0)
-                goto out;
-
-        ret = fs_path_add(fctx->dir_path, name, name_len);
-        if (ret < 0)
-                goto out;
-
-        if (!fctx->delete_pass) {
-                if (S_ISDIR(di_mode)) {
-                        ret = send_rename(sctx, fctx->cur_path,
-                                        fctx->dir_path);
-                } else {
-                        ret = send_link(sctx, fctx->dir_path,
-                                        fctx->cur_path);
-                        if (is_orphan)
-                                fctx->need_delete = 1;
-                }
-        } else if (!S_ISDIR(di_mode)) {
-                ret = send_unlink(sctx, fctx->cur_path);
-        } else {
-                ret = 0;
-        }
-
-        fs_path_remove(fctx->dir_path);
-
-out:
-        return ret;
-}
-
-/*
- * Go through all dir items and see if we find refs which could not be created
- * in the past because the dir did not exist at that time.
- */
-static int finish_outoforder_dir(struct send_ctx *sctx, u64 dir, u64 dir_gen)
-{
-        int ret = 0;
-        struct btrfs_path *path = NULL;
-        struct btrfs_key key;
-        struct btrfs_key found_key;
-        struct extent_buffer *eb;
-        struct finish_unordered_dir_ctx fctx;
-        int slot;
-
-        path = alloc_path_for_send();
-        if (!path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-
-        memset(&fctx, 0, sizeof(fctx));
-        fctx.sctx = sctx;
-        fctx.cur_path = fs_path_alloc(sctx);
-        fctx.dir_path = fs_path_alloc(sctx);
-        if (!fctx.cur_path || !fctx.dir_path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        fctx.dir_ino = dir;
-
-        ret = get_cur_path(sctx, dir, dir_gen, fctx.dir_path);
-        if (ret < 0)
-                goto out;
-
-        /*
-         * We do two passes. The first links in the new refs and the second
-         * deletes orphans if required. Deletion of orphans is not required for
-         * directory inodes, as we always have only one ref and use rename
-         * instead of link for those.
-         */
-
-again:
-        key.objectid = dir;
-        key.type = BTRFS_DIR_ITEM_KEY;
-        key.offset = 0;
-        while (1) {
-                ret = btrfs_search_slot_for_read(sctx->send_root, &key, path,
-                                1, 0);
-                if (ret < 0)
-                        goto out;
-                eb = path->nodes[0];
-                slot = path->slots[0];
-                btrfs_item_key_to_cpu(eb, &found_key, slot);
-
-                if (found_key.objectid != key.objectid ||
-                    found_key.type != key.type) {
-                        btrfs_release_path(path);
-                        break;
-                }
-
-                ret = iterate_dir_item(sctx, sctx->send_root, path,
-                                &found_key, __finish_unordered_dir,
-                                &fctx);
-                if (ret < 0)
-                        goto out;
-
-                key.offset = found_key.offset + 1;
-                btrfs_release_path(path);
-        }
-
-        if (!fctx.delete_pass && fctx.need_delete) {
-                fctx.delete_pass = 1;
-                goto again;
-        }
-
-out:
-        btrfs_free_path(path);
-        fs_path_free(sctx, fctx.cur_path);
-        fs_path_free(sctx, fctx.dir_path);
-        return ret;
-}
-
 /*
  * This does all the move/link/unlink/rmdir magic.
  */
@@ -2674,6 +2725,7 @@ static int process_recorded_refs(struct send_ctx *sctx)
 {
         int ret = 0;
         struct recorded_ref *cur;
+        struct recorded_ref *cur2;
         struct ulist *check_dirs = NULL;
         struct ulist_iterator uit;
         struct ulist_node *un;
@@ -2685,6 +2737,12 @@ static int process_recorded_refs(struct send_ctx *sctx)
 
 verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
 
+        /*
+         * This should never happen as the root dir always has the same ref
+         * which is always '..'
+         */
+        BUG_ON(sctx->cur_ino <= BTRFS_FIRST_FREE_OBJECTID);
+
         valid_path = fs_path_alloc(sctx);
         if (!valid_path) {
                 ret = -ENOMEM;
@@ -2731,6 +2789,46 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
 
         list_for_each_entry(cur, &sctx->new_refs, list) {
                 /*
+                 * We may have refs where the parent directory does not exist
+                 * yet. This happens if the parent directories inum is higher
+                 * the the current inum. To handle this case, we create the
+                 * parent directory out of order. But we need to check if this
+                 * did already happen before due to other refs in the same dir.
+                 */
+                ret = get_cur_inode_state(sctx, cur->dir, cur->dir_gen);
+                if (ret < 0)
+                        goto out;
+                if (ret == inode_state_will_create) {
+                        ret = 0;
+                        /*
+                         * First check if any of the current inodes refs did
+                         * already create the dir.
+                         */
+                        list_for_each_entry(cur2, &sctx->new_refs, list) {
+                                if (cur == cur2)
+                                        break;
+                                if (cur2->dir == cur->dir) {
+                                        ret = 1;
+                                        break;
+                                }
+                        }
+
+                        /*
+                         * If that did not happen, check if a previous inode
+                         * did already create the dir.
+                         */
+                        if (!ret)
+                                ret = did_create_dir(sctx, cur->dir);
+                        if (ret < 0)
+                                goto out;
+                        if (!ret) {
+                                ret = send_create_inode(sctx, cur->dir);
+                                if (ret < 0)
+                                        goto out;
+                        }
+                }
+
+                /*
                  * Check if this new ref would overwrite the first ref of
                  * another unprocessed inode. If yes, orphanize the
                  * overwritten inode. If we find an overwritten ref that is
@@ -2764,7 +2862,7 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                  * inode, move it and update valid_path. If not, link or move
                  * it depending on the inode mode.
                  */
-                if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+                if (is_orphan) {
                         ret = send_rename(sctx, valid_path, cur->full_path);
                         if (ret < 0)
                                 goto out;
@@ -2827,6 +2925,17 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                         if (ret < 0)
                                 goto out;
                 }
+        } else if (S_ISDIR(sctx->cur_inode_mode) &&
+                   !list_empty(&sctx->deleted_refs)) {
+                /*
+                 * We have a moved dir. Add the old parent to check_dirs
+                 */
+                cur = list_entry(sctx->deleted_refs.next, struct recorded_ref,
+                                list);
+                ret = ulist_add(check_dirs, cur->dir, cur->dir_gen,
+                                GFP_NOFS);
+                if (ret < 0)
+                        goto out;
         } else if (!S_ISDIR(sctx->cur_inode_mode)) {
                 /*
                  * We have a non dir inode. Go through all deleted refs and
@@ -2840,35 +2949,9 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                         if (ret < 0)
                                 goto out;
                         if (!ret) {
-                                /*
-                                 * In case the inode was moved to a directory
-                                 * that was not created yet (see
-                                 * __record_new_ref), we can not unlink the ref
-                                 * as it will be needed later when the parent
-                                 * directory is created, so that we can move in
-                                 * the inode to the new dir.
-                                 */
-                                if (!is_orphan &&
-                                    sctx->cur_inode_first_ref_orphan) {
-                                        ret = orphanize_inode(sctx,
-                                                        sctx->cur_ino,
-                                                        sctx->cur_inode_gen,
-                                                        cur->full_path);
-                                        if (ret < 0)
-                                                goto out;
-                                        ret = gen_unique_name(sctx,
-                                                        sctx->cur_ino,
-                                                        sctx->cur_inode_gen,
-                                                        valid_path);
-                                        if (ret < 0)
-                                                goto out;
-                                        is_orphan = 1;
-
-                                } else {
-                                        ret = send_unlink(sctx, cur->full_path);
-                                        if (ret < 0)
-                                                goto out;
-                                }
+                                ret = send_unlink(sctx, cur->full_path);
+                                if (ret < 0)
+                                        goto out;
                         }
                         ret = ulist_add(check_dirs, cur->dir, cur->dir_gen,
                                         GFP_NOFS);
@@ -2880,12 +2963,11 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                  * If the inode is still orphan, unlink the orphan. This may
                  * happen when a previous inode did overwrite the first ref
                  * of this inode and no new refs were added for the current
-                 * inode.
-                 * We can however not delete the orphan in case the inode relies
-                 * in a directory that was not created yet (see
-                 * __record_new_ref)
+                 * inode. Unlinking does not mean that the inode is deleted in
+                 * all cases. There may still be links to this inode in other
+                 * places.
                  */
-                if (is_orphan && !sctx->cur_inode_first_ref_orphan) {
+                if (is_orphan) {
                         ret = send_unlink(sctx, valid_path);
                         if (ret < 0)
                                 goto out;
@@ -2900,6 +2982,11 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
          */
         ULIST_ITER_INIT(&uit);
         while ((un = ulist_next(check_dirs, &uit))) {
+                /*
+                 * In case we had refs into dirs that were not processed yet,
+                 * we don't need to do the utime and rmdir logic for these dirs.
+                 * The dir will be processed later.
+                 */
                 if (un->val > sctx->cur_ino)
                         continue;
 
@@ -2929,25 +3016,6 @@ verbose_printk("btrfs: process_recorded_refs %llu\n", sctx->cur_ino);
                 }
         }
 
-        /*
-         * Current inode is now at it's new position, so we must increase
-         * send_progress
-         */
-        sctx->send_progress = sctx->cur_ino + 1;
-
-        /*
-         * We may have a directory here that has pending refs which could not
-         * be created before (because the dir did not exist before, see
-         * __record_new_ref). finish_outoforder_dir will link/move the pending
-         * refs.
-         */
-        if (S_ISDIR(sctx->cur_inode_mode) && sctx->cur_inode_new) {
-                ret = finish_outoforder_dir(sctx, sctx->cur_ino,
-                                sctx->cur_inode_gen);
-                if (ret < 0)
-                        goto out;
-        }
-
         ret = 0;
 
 out:
@@ -2971,34 +3039,9 @@ static int __record_new_ref(int num, u64 dir, int index,
                 return -ENOMEM;
 
         ret = get_inode_info(sctx->send_root, dir, NULL, &gen, NULL, NULL,
-                        NULL);
-        if (ret < 0)
-                goto out;
-
-        /*
-         * The parent may be non-existent at this point in time. This happens
-         * if the ino of the parent dir is higher then the current ino. In this
-         * case, we can not process this ref until the parent dir is finally
-         * created. If we reach the parent dir later, process_recorded_refs
-         * will go through all dir items and process the refs that could not be
-         * processed before. In case this is the first ref, we set
-         * cur_inode_first_ref_orphan to 1 to inform process_recorded_refs to
-         * keep an orphan of the inode so that it later can be used for
-         * link/move
-         */
-        ret = is_inode_existent(sctx, dir, gen);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
-        if (!ret) {
-                ret = is_first_ref(sctx, sctx->send_root, sctx->cur_ino, dir,
-                                name->start, fs_path_len(name));
-                if (ret < 0)
-                        goto out;
-                if (ret)
-                        sctx->cur_inode_first_ref_orphan = 1;
-                ret = 0;
-                goto out;
-        }
 
         ret = get_cur_path(sctx, dir, gen, p);
         if (ret < 0)
@@ -3029,7 +3072,7 @@ static int __record_deleted_ref(int num, u64 dir, int index,
                 return -ENOMEM;
 
         ret = get_inode_info(sctx->parent_root, dir, NULL, &gen, NULL, NULL,
-                        NULL);
+                        NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -3206,33 +3249,29 @@ static int process_all_refs(struct send_ctx *sctx,
         key.offset = 0;
         while (1) {
                 ret = btrfs_search_slot_for_read(root, &key, path, 1, 0);
-                if (ret < 0) {
-                        btrfs_release_path(path);
+                if (ret < 0)
                         goto out;
-                }
-                if (ret) {
-                        btrfs_release_path(path);
+                if (ret)
                         break;
-                }
 
                 eb = path->nodes[0];
                 slot = path->slots[0];
                 btrfs_item_key_to_cpu(eb, &found_key, slot);
 
                 if (found_key.objectid != key.objectid ||
-                    found_key.type != key.type) {
-                        btrfs_release_path(path);
+                    (found_key.type != BTRFS_INODE_REF_KEY &&
+                     found_key.type != BTRFS_INODE_EXTREF_KEY))
                         break;
-                }
 
-                ret = iterate_inode_ref(sctx, sctx->parent_root, path,
-                                &found_key, 0, cb, sctx);
+                ret = iterate_inode_ref(sctx, root, path, &found_key, 0, cb,
+                                sctx);
                 btrfs_release_path(path);
                 if (ret < 0)
                         goto out;
 
                 key.offset = found_key.offset + 1;
         }
+        btrfs_release_path(path);
 
         ret = process_recorded_refs(sctx);
 
@@ -3555,7 +3594,7 @@ static int send_write(struct send_ctx *sctx, u64 offset, u32 len)
         int ret = 0;
         struct fs_path *p;
         loff_t pos = offset;
-        int readed = 0;
+        int num_read = 0;
         mm_segment_t old_fs;
 
         p = fs_path_alloc(sctx);
@@ -3580,8 +3619,8 @@ verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
         ret = vfs_read(sctx->cur_inode_filp, sctx->read_buf, len, &pos);
         if (ret < 0)
                 goto out;
-        readed = ret;
-        if (!readed)
+        num_read = ret;
+        if (!num_read)
                 goto out;
 
         ret = begin_cmd(sctx, BTRFS_SEND_C_WRITE);
@@ -3594,7 +3633,7 @@ verbose_printk("btrfs: send_write offset=%llu, len=%d\n", offset, len);
 
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
-        TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, readed);
+        TLV_PUT(sctx, BTRFS_SEND_A_DATA, sctx->read_buf, num_read);
 
         ret = send_cmd(sctx);
 
@@ -3604,7 +3643,7 @@ out:
         set_fs(old_fs);
         if (ret < 0)
                 return ret;
-        return readed;
+        return num_read;
 }
 
 /*
@@ -3615,7 +3654,6 @@ static int send_clone(struct send_ctx *sctx,
                       struct clone_root *clone_root)
 {
         int ret = 0;
-        struct btrfs_root *clone_root2 = clone_root->root;
         struct fs_path *p;
         u64 gen;
 
@@ -3640,22 +3678,23 @@ verbose_printk("btrfs: send_clone offset=%llu, len=%d, clone_root=%llu, "
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_LEN, len);
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, p);
 
-        if (clone_root2 == sctx->send_root) {
+        if (clone_root->root == sctx->send_root) {
                 ret = get_inode_info(sctx->send_root, clone_root->ino, NULL,
-                                &gen, NULL, NULL, NULL);
+                                &gen, NULL, NULL, NULL, NULL);
                 if (ret < 0)
                         goto out;
                 ret = get_cur_path(sctx, clone_root->ino, gen, p);
         } else {
-                ret = get_inode_path(sctx, clone_root2, clone_root->ino, p);
+                ret = get_inode_path(sctx, clone_root->root,
+                                clone_root->ino, p);
         }
         if (ret < 0)
                 goto out;
 
         TLV_PUT_UUID(sctx, BTRFS_SEND_A_CLONE_UUID,
-                        clone_root2->root_item.uuid);
+                        clone_root->root->root_item.uuid);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_CTRANSID,
-                        clone_root2->root_item.ctransid);
+                        clone_root->root->root_item.ctransid);
         TLV_PUT_PATH(sctx, BTRFS_SEND_A_CLONE_PATH, p);
         TLV_PUT_U64(sctx, BTRFS_SEND_A_CLONE_OFFSET,
                         clone_root->offset);
@@ -3684,10 +3723,17 @@ static int send_write_or_clone(struct send_ctx *sctx,
         ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
                         struct btrfs_file_extent_item);
         type = btrfs_file_extent_type(path->nodes[0], ei);
-        if (type == BTRFS_FILE_EXTENT_INLINE)
+        if (type == BTRFS_FILE_EXTENT_INLINE) {
                 len = btrfs_file_extent_inline_len(path->nodes[0], ei);
-        else
+                /*
+                 * it is possible the inline item won't cover the whole page,
+                 * but there may be items after this page.  Make
+                 * sure to send the whole thing
+                 */
+                len = PAGE_CACHE_ALIGN(len);
+        } else {
                 len = btrfs_file_extent_num_bytes(path->nodes[0], ei);
+        }
 
         if (offset + len > sctx->cur_inode_size)
                 len = sctx->cur_inode_size - offset;
@@ -3735,6 +3781,8 @@ static int is_extent_unchanged(struct send_ctx *sctx,
         u64 left_offset_fixed;
         u64 left_len;
         u64 right_len;
+        u64 left_gen;
+        u64 right_gen;
         u8 left_type;
         u8 right_type;
 
@@ -3744,17 +3792,17 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 
         eb = left_path->nodes[0];
         slot = left_path->slots[0];
-
         ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
         left_type = btrfs_file_extent_type(eb, ei);
-        left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
-        left_len = btrfs_file_extent_num_bytes(eb, ei);
-        left_offset = btrfs_file_extent_offset(eb, ei);
 
         if (left_type != BTRFS_FILE_EXTENT_REG) {
                 ret = 0;
                 goto out;
         }
+        left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
+        left_len = btrfs_file_extent_num_bytes(eb, ei);
+        left_offset = btrfs_file_extent_offset(eb, ei);
+        left_gen = btrfs_file_extent_generation(eb, ei);
 
         /*
          * Following comments will refer to these graphics. L is the left
@@ -3810,6 +3858,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                 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;
@@ -3820,7 +3869,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                  * Are we at extent 8? If yes, we know the extent is changed.
                  * This may only happen on the first iteration.
                  */
-                if (found_key.offset + right_len < ekey->offset) {
+                if (found_key.offset + right_len <= ekey->offset) {
                         ret = 0;
                         goto out;
                 }
@@ -3837,8 +3886,9 @@ static int is_extent_unchanged(struct send_ctx *sctx,
                 /*
                  * Check if we have the same extent.
                  */
-                if (left_disknr + left_offset_fixed !=
-                                right_disknr + right_offset) {
+                if (left_disknr != right_disknr ||
+                    left_offset_fixed != right_offset ||
+                    left_gen != right_gen) {
                         ret = 0;
                         goto out;
                 }
@@ -3971,12 +4021,21 @@ static int process_recorded_refs_if_needed(struct send_ctx *sctx, int at_end)
         if (sctx->cur_ino == 0)
                 goto out;
         if (!at_end && sctx->cur_ino == sctx->cmp_key->objectid &&
-            sctx->cmp_key->type <= BTRFS_INODE_REF_KEY)
+            sctx->cmp_key->type <= BTRFS_INODE_EXTREF_KEY)
                 goto out;
         if (list_empty(&sctx->new_refs) && list_empty(&sctx->deleted_refs))
                 goto out;
 
         ret = process_recorded_refs(sctx);
+        if (ret < 0)
+                goto out;
+
+        /*
+         * We have processed the refs and thus need to advance send_progress.
+         * Now, calls to get_cur_xxx will take the updated refs of the current
+         * inode into account.
+         */
+        sctx->send_progress = sctx->cur_ino + 1;
 
 out:
         return ret;
@@ -4004,26 +4063,25 @@ static int finish_inode_if_needed(struct send_ctx *sctx, int at_end)
                 goto out;
 
         ret = get_inode_info(sctx->send_root, sctx->cur_ino, NULL, NULL,
-                        &left_mode, &left_uid, &left_gid);
+                        &left_mode, &left_uid, &left_gid, NULL);
         if (ret < 0)
                 goto out;
 
-        if (!S_ISLNK(sctx->cur_inode_mode)) {
-                if (!sctx->parent_root || sctx->cur_inode_new) {
+        if (!sctx->parent_root || sctx->cur_inode_new) {
+                need_chown = 1;
+                if (!S_ISLNK(sctx->cur_inode_mode))
                         need_chmod = 1;
-                        need_chown = 1;
-                } else {
-                        ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
-                                        NULL, NULL, &right_mode, &right_uid,
-                                        &right_gid);
-                        if (ret < 0)
-                                goto out;
+        } else {
+                ret = get_inode_info(sctx->parent_root, sctx->cur_ino,
+                                NULL, NULL, &right_mode, &right_uid,
+                                &right_gid, NULL);
+                if (ret < 0)
+                        goto out;
 
-                        if (left_uid != right_uid || left_gid != right_gid)
-                                need_chown = 1;
-                        if (left_mode != right_mode)
-                                need_chmod = 1;
-                }
+                if (left_uid != right_uid || left_gid != right_gid)
+                        need_chown = 1;
+                if (!S_ISLNK(sctx->cur_inode_mode) && left_mode != right_mode)
+                        need_chmod = 1;
         }
 
         if (S_ISREG(sctx->cur_inode_mode)) {
@@ -4074,7 +4132,12 @@ static int changed_inode(struct send_ctx *sctx,
 
         sctx->cur_ino = key->objectid;
         sctx->cur_inode_new_gen = 0;
-        sctx->cur_inode_first_ref_orphan = 0;
+
+        /*
+         * Set send_progress to current inode. This will tell all get_cur_xxx
+         * functions that the current inode's refs are not updated yet. Later,
+         * when process_recorded_refs is finished, it is set to cur_ino + 1.
+         */
         sctx->send_progress = sctx->cur_ino;
 
         if (result == BTRFS_COMPARE_TREE_NEW ||
@@ -4098,7 +4161,14 @@ static int changed_inode(struct send_ctx *sctx,
 
                 right_gen = btrfs_inode_generation(sctx->right_path->nodes[0],
                                 right_ii);
-                if (left_gen != right_gen)
+
+                /*
+                 * The cur_ino = root dir case is special here. We can't treat
+                 * the inode as deleted+reused because it would generate a
+                 * stream that tries to delete/mkdir the root dir.
+                 */
+                if (left_gen != right_gen &&
+                    sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
                         sctx->cur_inode_new_gen = 1;
         }
 
@@ -4111,8 +4181,7 @@ static int changed_inode(struct send_ctx *sctx,
                 sctx->cur_inode_mode = btrfs_inode_mode(
                                 sctx->left_path->nodes[0], left_ii);
                 if (sctx->cur_ino != BTRFS_FIRST_FREE_OBJECTID)
-                        ret = send_create_inode(sctx, sctx->left_path,
-                                        sctx->cmp_key);
+                        ret = send_create_inode_if_needed(sctx);
         } else if (result == BTRFS_COMPARE_TREE_DELETED) {
                 sctx->cur_inode_gen = right_gen;
                 sctx->cur_inode_new = 0;
@@ -4122,7 +4191,17 @@ static int changed_inode(struct send_ctx *sctx,
                 sctx->cur_inode_mode = btrfs_inode_mode(
                                 sctx->right_path->nodes[0], right_ii);
         } else if (result == BTRFS_COMPARE_TREE_CHANGED) {
+                /*
+                 * We need to do some special handling in case the inode was
+                 * reported as changed with a changed generation number. This
+                 * means that the original inode was deleted and new inode
+                 * reused the same inum. So we have to treat the old inode as
+                 * deleted and the new one as new.
+                 */
                 if (sctx->cur_inode_new_gen) {
+                        /*
+                         * First, process the inode as if it was deleted.
+                         */
                         sctx->cur_inode_gen = right_gen;
                         sctx->cur_inode_new = 0;
                         sctx->cur_inode_deleted = 1;
@@ -4135,6 +4214,9 @@ static int changed_inode(struct send_ctx *sctx,
                         if (ret < 0)
                                 goto out;
 
+                        /*
+                         * Now process the inode as if it was new.
+                         */
                         sctx->cur_inode_gen = left_gen;
                         sctx->cur_inode_new = 1;
                         sctx->cur_inode_deleted = 0;
@@ -4142,14 +4224,23 @@ static int changed_inode(struct send_ctx *sctx,
                                         sctx->left_path->nodes[0], left_ii);
                         sctx->cur_inode_mode = btrfs_inode_mode(
                                         sctx->left_path->nodes[0], left_ii);
-                        ret = send_create_inode(sctx, sctx->left_path,
-                                        sctx->cmp_key);
+                        ret = send_create_inode_if_needed(sctx);
                         if (ret < 0)
                                 goto out;
 
                         ret = process_all_refs(sctx, BTRFS_COMPARE_TREE_NEW);
                         if (ret < 0)
                                 goto out;
+                        /*
+                         * Advance send_progress now as we did not get into
+                         * process_recorded_refs_if_needed in the new_gen case.
+                         */
+                        sctx->send_progress = sctx->cur_ino + 1;
+
+                        /*
+                         * Now process all extents and xattrs of the inode as if
+                         * they were all new.
+                         */
                         ret = process_all_extents(sctx);
                         if (ret < 0)
                                 goto out;
@@ -4172,6 +4263,16 @@ out:
         return ret;
 }
 
+/*
+ * We have to process new refs before deleted refs, but compare_trees gives us
+ * the new and deleted refs mixed. To fix this, we record the new/deleted refs
+ * first and later process them in process_recorded_refs.
+ * For the cur_inode_new_gen case, we skip recording completely because
+ * changed_inode did already initiate processing of refs. The reason for this is
+ * that in this case, compare_tree actually compares the refs of 2 different
+ * inodes. To fix this, process_all_refs is used in changed_inode to handle all
+ * refs of the right tree as deleted and all refs of the left tree as new.
+ */
 static int changed_ref(struct send_ctx *sctx,
                        enum btrfs_compare_tree_result result)
 {
@@ -4192,6 +4293,11 @@ static int changed_ref(struct send_ctx *sctx,
         return ret;
 }
 
+/*
+ * Process new/deleted/changed xattrs. We skip processing in the
+ * cur_inode_new_gen case because changed_inode did already initiate processing
+ * of xattrs. The reason is the same as in changed_ref
+ */
 static int changed_xattr(struct send_ctx *sctx,
                          enum btrfs_compare_tree_result result)
 {
@@ -4211,6 +4317,11 @@ static int changed_xattr(struct send_ctx *sctx,
         return ret;
 }
 
+/*
+ * Process new/deleted/changed extents. We skip processing in the
+ * cur_inode_new_gen case because changed_inode did already initiate processing
+ * of extents. The reason is the same as in changed_ref
+ */
 static int changed_extent(struct send_ctx *sctx,
                           enum btrfs_compare_tree_result result)
 {
@@ -4227,7 +4338,10 @@ static int changed_extent(struct send_ctx *sctx,
         return ret;
 }
 
-
+/*
+ * Updates compare related fields in sctx and simply forwards to the actual
+ * changed_xxx functions.
+ */
 static int changed_cb(struct btrfs_root *left_root,
                       struct btrfs_root *right_root,
                       struct btrfs_path *left_path,
@@ -4247,9 +4361,15 @@ static int changed_cb(struct btrfs_root *left_root,
         if (ret < 0)
                 goto out;
 
+        /* Ignore non-FS objects */
+        if (key->objectid == BTRFS_FREE_INO_OBJECTID ||
+            key->objectid == BTRFS_FREE_SPACE_OBJECTID)
+                goto out;
+
         if (key->type == BTRFS_INODE_ITEM_KEY)
                 ret = changed_inode(sctx, result);
-        else if (key->type == BTRFS_INODE_REF_KEY)
+        else if (key->type == BTRFS_INODE_REF_KEY ||
+                 key->type == BTRFS_INODE_EXTREF_KEY)
                 ret = changed_ref(sctx, result);
         else if (key->type == BTRFS_XATTR_ITEM_KEY)
                 ret = changed_xattr(sctx, result);
@@ -4277,9 +4397,9 @@ static int full_send_tree(struct send_ctx *sctx)
         if (!path)
                 return -ENOMEM;
 
-        spin_lock(&send_root->root_times_lock);
+        spin_lock(&send_root->root_item_lock);
         start_ctransid = btrfs_root_ctransid(&send_root->root_item);
-        spin_unlock(&send_root->root_times_lock);
+        spin_unlock(&send_root->root_item_lock);
 
         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
         key.type = BTRFS_INODE_ITEM_KEY;
@@ -4299,11 +4419,12 @@ join_trans:
         }
 
         /*
-         * Make sure the tree has not changed
+         * Make sure the tree has not changed after re-joining. We detect this
+         * by comparing start_ctransid and ctransid. They should always match.
          */
-        spin_lock(&send_root->root_times_lock);
+        spin_lock(&send_root->root_item_lock);
         ctransid = btrfs_root_ctransid(&send_root->root_item);
-        spin_unlock(&send_root->root_times_lock);
+        spin_unlock(&send_root->root_item_lock);
 
         if (ctransid != start_ctransid) {
                 WARN(1, KERN_WARNING "btrfs: the root that you're trying to "
diff --git a/fs/btrfs/send.h b/fs/btrfs/send.h
index 9934e948e57f..1bf4f32fd4ef 100644
--- a/fs/btrfs/send.h
+++ b/fs/btrfs/send.h
@@ -130,4 +130,5 @@ enum {
 
 #ifdef __KERNEL__
 long btrfs_ioctl_send(struct file *mnt_file, void __user *arg);
+int write_buf(struct file *filp, const void *buf, u32 len, loff_t *off);
 #endif
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 83d6f9f9c220..99545df1b86c 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -55,6 +55,7 @@
 #include "export.h"
 #include "compression.h"
 #include "rcu-string.h"
+#include "dev-replace.h"
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/btrfs.h>
@@ -116,7 +117,16 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
         if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
                 sb->s_flags |= MS_RDONLY;
                 printk(KERN_INFO "btrfs is forced readonly\n");
-                __btrfs_scrub_cancel(fs_info);
+                /*
+                 * Note that a running device replace operation is not
+                 * canceled here although there is no way to update
+                 * the progress. It would add the risk of a deadlock,
+                 * therefore the canceling is ommited. The only penalty
+                 * is that some I/O remains active until the procedure
+                 * completes. The next time when the filesystem is
+                 * mounted writeable again, the device replace
+                 * operation continues.
+                 */
 //              WARN_ON(1);
         }
 }
@@ -243,12 +253,18 @@ void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root, const char *function,
                                unsigned int line, int errno)
 {
-        WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted");
+        WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted\n");
         trans->aborted = errno;
         /* Nothing used. The other threads that have joined this
          * transaction may be able to continue. */
         if (!trans->blocks_used) {
-                btrfs_printk(root->fs_info, "Aborting unused transaction.\n");
+                char nbuf[16];
+                const char *errstr;
+
+                errstr = btrfs_decode_error(root->fs_info, errno, nbuf);
+                btrfs_printk(root->fs_info,
+                             "%s:%d: Aborting unused transaction(%s).\n",
+                             function, line, errstr);
                 return;
         }
         trans->transaction->aborted = errno;
@@ -407,7 +423,15 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_set_opt(info->mount_opt, NODATASUM);
                         break;
                 case Opt_nodatacow:
-                        printk(KERN_INFO "btrfs: setting nodatacow\n");
+                        if (!btrfs_test_opt(root, COMPRESS) ||
+                                !btrfs_test_opt(root, FORCE_COMPRESS)) {
+                                        printk(KERN_INFO "btrfs: setting nodatacow, compression disabled\n");
+                        } else {
+                                printk(KERN_INFO "btrfs: setting nodatacow\n");
+                        }
+                        info->compress_type = BTRFS_COMPRESS_NONE;
+                        btrfs_clear_opt(info->mount_opt, COMPRESS);
+                        btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
                         btrfs_set_opt(info->mount_opt, NODATACOW);
                         btrfs_set_opt(info->mount_opt, NODATASUM);
                         break;
@@ -422,10 +446,14 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                                 compress_type = "zlib";
                                 info->compress_type = BTRFS_COMPRESS_ZLIB;
                                 btrfs_set_opt(info->mount_opt, COMPRESS);
+                                btrfs_clear_opt(info->mount_opt, NODATACOW);
+                                btrfs_clear_opt(info->mount_opt, NODATASUM);
                         } else if (strcmp(args[0].from, "lzo") == 0) {
                                 compress_type = "lzo";
                                 info->compress_type = BTRFS_COMPRESS_LZO;
                                 btrfs_set_opt(info->mount_opt, COMPRESS);
+                                btrfs_clear_opt(info->mount_opt, NODATACOW);
+                                btrfs_clear_opt(info->mount_opt, NODATASUM);
                                 btrfs_set_fs_incompat(info, COMPRESS_LZO);
                         } else if (strncmp(args[0].from, "no", 2) == 0) {
                                 compress_type = "no";
@@ -543,11 +571,11 @@ int btrfs_parse_options(struct btrfs_root *root, char *options)
                         btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
                         break;
                 case Opt_defrag:
-                        printk(KERN_INFO "btrfs: enabling auto defrag");
+                        printk(KERN_INFO "btrfs: enabling auto defrag\n");
                         btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
                         break;
                 case Opt_recovery:
-                        printk(KERN_INFO "btrfs: enabling auto recovery");
+                        printk(KERN_INFO "btrfs: enabling auto recovery\n");
                         btrfs_set_opt(info->mount_opt, RECOVERY);
                         break;
                 case Opt_skip_balance:
@@ -846,18 +874,15 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
                 return 0;
         }
 
-        btrfs_wait_ordered_extents(root, 0, 0);
+        btrfs_wait_ordered_extents(root, 0);
 
-        spin_lock(&fs_info->trans_lock);
-        if (!fs_info->running_transaction) {
-                spin_unlock(&fs_info->trans_lock);
-                return 0;
-        }
-        spin_unlock(&fs_info->trans_lock);
-
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans))
+        trans = btrfs_attach_transaction(root);
+        if (IS_ERR(trans)) {
+                /* no transaction, don't bother */
+                if (PTR_ERR(trans) == -ENOENT)
+                        return 0;
                 return PTR_ERR(trans);
+        }
         return btrfs_commit_transaction(trans, root);
 }
 
@@ -1171,7 +1196,8 @@ static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
         btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
         btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
         btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
-        btrfs_set_max_workers(&fs_info->scrub_workers, new_pool_size);
+        btrfs_set_max_workers(&fs_info->scrub_wr_completion_workers,
+                              new_pool_size);
 }
 
 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
@@ -1200,8 +1226,15 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                 return 0;
 
         if (*flags & MS_RDONLY) {
+                /*
+                 * this also happens on 'umount -rf' or on shutdown, when
+                 * the filesystem is busy.
+                 */
                 sb->s_flags |= MS_RDONLY;
 
+                btrfs_dev_replace_suspend_for_unmount(fs_info);
+                btrfs_scrub_cancel(fs_info);
+
                 ret = btrfs_commit_super(root);
                 if (ret)
                         goto restore;
@@ -1211,6 +1244,15 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                         goto restore;
                 }
 
+                if (fs_info->fs_devices->missing_devices >
+                     fs_info->num_tolerated_disk_barrier_failures &&
+                    !(*flags & MS_RDONLY)) {
+                        printk(KERN_WARNING
+                               "Btrfs: too many missing devices, writeable remount is not allowed\n");
+                        ret = -EACCES;
+                        goto restore;
+                }
+
                 if (btrfs_super_log_root(fs_info->super_copy) != 0) {
                         ret = -EINVAL;
                         goto restore;
@@ -1229,6 +1271,11 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                 if (ret)
                         goto restore;
 
+                ret = btrfs_resume_dev_replace_async(fs_info);
+                if (ret) {
+                        pr_warn("btrfs: failed to resume dev_replace\n");
+                        goto restore;
+                }
                 sb->s_flags &= ~MS_RDONLY;
         }
 
@@ -1321,7 +1368,8 @@ static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
                 min_stripe_size = BTRFS_STRIPE_LEN;
 
         list_for_each_entry(device, &fs_devices->devices, dev_list) {
-                if (!device->in_fs_metadata || !device->bdev)
+                if (!device->in_fs_metadata || !device->bdev ||
+                    device->is_tgtdev_for_dev_replace)
                         continue;
 
                 avail_space = device->total_bytes - device->bytes_used;
@@ -1508,17 +1556,21 @@ static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
 
 static int btrfs_freeze(struct super_block *sb)
 {
-        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-        mutex_lock(&fs_info->transaction_kthread_mutex);
-        mutex_lock(&fs_info->cleaner_mutex);
-        return 0;
+        struct btrfs_trans_handle *trans;
+        struct btrfs_root *root = btrfs_sb(sb)->tree_root;
+
+        trans = btrfs_attach_transaction(root);
+        if (IS_ERR(trans)) {
+                /* no transaction, don't bother */
+                if (PTR_ERR(trans) == -ENOENT)
+                        return 0;
+                return PTR_ERR(trans);
+        }
+        return btrfs_commit_transaction(trans, root);
 }
 
 static int btrfs_unfreeze(struct super_block *sb)
 {
-        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-        mutex_unlock(&fs_info->cleaner_mutex);
-        mutex_unlock(&fs_info->transaction_kthread_mutex);
         return 0;
 }
 
@@ -1595,7 +1647,7 @@ static int btrfs_interface_init(void)
 static void btrfs_interface_exit(void)
 {
         if (misc_deregister(&btrfs_misc) < 0)
-                printk(KERN_INFO "misc_deregister failed for control device");
+                printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
 }
 
 static int __init init_btrfs_fs(void)
@@ -1620,14 +1672,22 @@ static int __init init_btrfs_fs(void)
         if (err)
                 goto free_extent_io;
 
-        err = btrfs_delayed_inode_init();
+        err = ordered_data_init();
         if (err)
                 goto free_extent_map;
 
-        err = btrfs_interface_init();
+        err = btrfs_delayed_inode_init();
+        if (err)
+                goto free_ordered_data;
+
+        err = btrfs_auto_defrag_init();
         if (err)
                 goto free_delayed_inode;
 
+        err = btrfs_interface_init();
+        if (err)
+                goto free_auto_defrag;
+
         err = register_filesystem(&btrfs_fs_type);
         if (err)
                 goto unregister_ioctl;
@@ -1639,8 +1699,12 @@ static int __init init_btrfs_fs(void)
 
 unregister_ioctl:
         btrfs_interface_exit();
+free_auto_defrag:
+        btrfs_auto_defrag_exit();
 free_delayed_inode:
         btrfs_delayed_inode_exit();
+free_ordered_data:
+        ordered_data_exit();
 free_extent_map:
         extent_map_exit();
 free_extent_io:
@@ -1656,7 +1720,9 @@ free_compress:
 static void __exit exit_btrfs_fs(void)
 {
         btrfs_destroy_cachep();
+        btrfs_auto_defrag_exit();
         btrfs_delayed_inode_exit();
+        ordered_data_exit();
         extent_map_exit();
         extent_io_exit();
         btrfs_interface_exit();
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 27c26004e050..87fac9a21ea5 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -30,6 +30,7 @@
 #include "tree-log.h"
 #include "inode-map.h"
 #include "volumes.h"
+#include "dev-replace.h"
 
 #define BTRFS_ROOT_TRANS_TAG 0
 
@@ -53,7 +54,7 @@ static noinline void switch_commit_root(struct btrfs_root *root)
 /*
  * either allocate a new transaction or hop into the existing one
  */
-static noinline int join_transaction(struct btrfs_root *root, int nofail)
+static noinline int join_transaction(struct btrfs_root *root, int type)
 {
         struct btrfs_transaction *cur_trans;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -67,7 +68,13 @@ loop:
         }
 
         if (fs_info->trans_no_join) {
-                if (!nofail) {
+                /* 
+                 * If we are JOIN_NOLOCK we're already committing a current
+                 * transaction, we just need a handle to deal with something
+                 * when committing the transaction, such as inode cache and
+                 * space cache. It is a special case.
+                 */
+                if (type != TRANS_JOIN_NOLOCK) {
                         spin_unlock(&fs_info->trans_lock);
                         return -EBUSY;
                 }
@@ -87,6 +94,13 @@ loop:
         }
         spin_unlock(&fs_info->trans_lock);
 
+        /*
+         * If we are ATTACH, we just want to catch the current transaction,
+         * and commit it. If there is no transaction, just return ENOENT.
+         */
+        if (type == TRANS_ATTACH)
+                return -ENOENT;
+
         cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
         if (!cur_trans)
                 return -ENOMEM;
@@ -132,16 +146,12 @@ loop:
          * the log must never go across transaction boundaries.
          */
         smp_mb();
-        if (!list_empty(&fs_info->tree_mod_seq_list)) {
-                printk(KERN_ERR "btrfs: tree_mod_seq_list not empty when "
+        if (!list_empty(&fs_info->tree_mod_seq_list))
+                WARN(1, KERN_ERR "btrfs: tree_mod_seq_list not empty when "
                         "creating a fresh transaction\n");
-                WARN_ON(1);
-        }
-        if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) {
-                printk(KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
+        if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
+                WARN(1, KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
                         "creating a fresh transaction\n");
-                WARN_ON(1);
-        }
         atomic_set(&fs_info->tree_mod_seq, 0);
 
         spin_lock_init(&cur_trans->commit_lock);
@@ -267,13 +277,6 @@ static void wait_current_trans(struct btrfs_root *root)
         }
 }
 
-enum btrfs_trans_type {
-        TRANS_START,
-        TRANS_JOIN,
-        TRANS_USERSPACE,
-        TRANS_JOIN_NOLOCK,
-};
-
 static int may_wait_transaction(struct btrfs_root *root, int type)
 {
         if (root->fs_info->log_root_recovering)
@@ -289,8 +292,9 @@ static int may_wait_transaction(struct btrfs_root *root, int type)
         return 0;
 }
 
-static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
-                                                    u64 num_items, int type)
+static struct btrfs_trans_handle *
+start_transaction(struct btrfs_root *root, u64 num_items, int type,
+                  enum btrfs_reserve_flush_enum flush)
 {
         struct btrfs_trans_handle *h;
         struct btrfs_transaction *cur_trans;
@@ -305,6 +309,7 @@ static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
                 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
                 h = current->journal_info;
                 h->use_count++;
+                WARN_ON(h->use_count > 2);
                 h->orig_rsv = h->block_rsv;
                 h->block_rsv = NULL;
                 goto got_it;
@@ -326,7 +331,7 @@ static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
                 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
                 ret = btrfs_block_rsv_add(root,
                                           &root->fs_info->trans_block_rsv,
-                                          num_bytes);
+                                          num_bytes, flush);
                 if (ret)
                         return ERR_PTR(ret);
         }
@@ -335,19 +340,34 @@ again:
         if (!h)
                 return ERR_PTR(-ENOMEM);
 
-        sb_start_intwrite(root->fs_info->sb);
+        /*
+         * If we are JOIN_NOLOCK we're already committing a transaction and
+         * waiting on this guy, so we don't need to do the sb_start_intwrite
+         * because we're already holding a ref.  We need this because we could
+         * have raced in and did an fsync() on a file which can kick a commit
+         * and then we deadlock with somebody doing a freeze.
+         *
+         * If we are ATTACH, it means we just want to catch the current
+         * transaction and commit it, so we needn't do sb_start_intwrite(). 
+         */
+        if (type < TRANS_JOIN_NOLOCK)
+                sb_start_intwrite(root->fs_info->sb);
 
         if (may_wait_transaction(root, type))
                 wait_current_trans(root);
 
         do {
-                ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
+                ret = join_transaction(root, type);
                 if (ret == -EBUSY)
                         wait_current_trans(root);
         } while (ret == -EBUSY);
 
         if (ret < 0) {
-                sb_end_intwrite(root->fs_info->sb);
+                /* We must get the transaction if we are JOIN_NOLOCK. */
+                BUG_ON(type == TRANS_JOIN_NOLOCK);
+
+                if (type < TRANS_JOIN_NOLOCK)
+                        sb_end_intwrite(root->fs_info->sb);
                 kmem_cache_free(btrfs_trans_handle_cachep, h);
                 return ERR_PTR(ret);
         }
@@ -367,7 +387,9 @@ again:
         h->aborted = 0;
         h->qgroup_reserved = qgroup_reserved;
         h->delayed_ref_elem.seq = 0;
+        h->type = type;
         INIT_LIST_HEAD(&h->qgroup_ref_list);
+        INIT_LIST_HEAD(&h->new_bgs);
 
         smp_mb();
         if (cur_trans->blocked && may_wait_transaction(root, type)) {
@@ -393,21 +415,35 @@ got_it:
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                    int num_items)
 {
-        return start_transaction(root, num_items, TRANS_START);
+        return start_transaction(root, num_items, TRANS_START,
+                                 BTRFS_RESERVE_FLUSH_ALL);
+}
+
+struct btrfs_trans_handle *btrfs_start_transaction_lflush(
+                                        struct btrfs_root *root, int num_items)
+{
+        return start_transaction(root, num_items, TRANS_START,
+                                 BTRFS_RESERVE_FLUSH_LIMIT);
 }
+
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_JOIN);
+        return start_transaction(root, 0, TRANS_JOIN, 0);
 }
 
 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
+        return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
 }
 
 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
 {
-        return start_transaction(root, 0, TRANS_USERSPACE);
+        return start_transaction(root, 0, TRANS_USERSPACE, 0);
+}
+
+struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
+{
+        return start_transaction(root, 0, TRANS_ATTACH, 0);
 }
 
 /* wait for a transaction commit to be fully complete */
@@ -420,28 +456,31 @@ static noinline void wait_for_commit(struct btrfs_root *root,
 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
 {
         struct btrfs_transaction *cur_trans = NULL, *t;
-        int ret;
+        int ret = 0;
 
-        ret = 0;
         if (transid) {
                 if (transid <= root->fs_info->last_trans_committed)
                         goto out;
 
+                ret = -EINVAL;
                 /* find specified transaction */
                 spin_lock(&root->fs_info->trans_lock);
                 list_for_each_entry(t, &root->fs_info->trans_list, list) {
                         if (t->transid == transid) {
                                 cur_trans = t;
                                 atomic_inc(&cur_trans->use_count);
+                                ret = 0;
                                 break;
                         }
-                        if (t->transid > transid)
+                        if (t->transid > transid) {
+                                ret = 0;
                                 break;
+                        }
                 }
                 spin_unlock(&root->fs_info->trans_lock);
-                ret = -EINVAL;
+                /* The specified transaction doesn't exist */
                 if (!cur_trans)
-                        goto out;  /* bad transid */
+                        goto out;
         } else {
                 /* find newest transaction that is committing | committed */
                 spin_lock(&root->fs_info->trans_lock);
@@ -461,9 +500,7 @@ int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
         }
 
         wait_for_commit(root, cur_trans);
-
         put_transaction(cur_trans);
-        ret = 0;
 out:
         return ret;
 }
@@ -506,11 +543,12 @@ int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
 }
 
 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *root, int throttle, int lock)
+                          struct btrfs_root *root, int throttle)
 {
         struct btrfs_transaction *cur_trans = trans->transaction;
         struct btrfs_fs_info *info = root->fs_info;
         int count = 0;
+        int lock = (trans->type != TRANS_JOIN_NOLOCK);
         int err = 0;
 
         if (--trans->use_count) {
@@ -536,6 +574,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
                 trans->qgroup_reserved = 0;
         }
 
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
+
         while (count < 2) {
                 unsigned long cur = trans->delayed_ref_updates;
                 trans->delayed_ref_updates = 0;
@@ -551,7 +592,8 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
         btrfs_trans_release_metadata(trans, root);
         trans->block_rsv = NULL;
 
-        sb_end_intwrite(root->fs_info->sb);
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
 
         if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
             should_end_transaction(trans, root)) {
@@ -573,6 +615,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
                 }
         }
 
+        if (trans->type < TRANS_JOIN_NOLOCK)
+                sb_end_intwrite(root->fs_info->sb);
+
         WARN_ON(cur_trans != info->running_transaction);
         WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
         atomic_dec(&cur_trans->num_writers);
@@ -604,7 +649,7 @@ int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 {
         int ret;
 
-        ret = __btrfs_end_transaction(trans, root, 0, 1);
+        ret = __btrfs_end_transaction(trans, root, 0);
         if (ret)
                 return ret;
         return 0;
@@ -615,18 +660,7 @@ int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 {
         int ret;
 
-        ret = __btrfs_end_transaction(trans, root, 1, 1);
-        if (ret)
-                return ret;
-        return 0;
-}
-
-int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
-                                 struct btrfs_root *root)
-{
-        int ret;
-
-        ret = __btrfs_end_transaction(trans, root, 0, 0);
+        ret = __btrfs_end_transaction(trans, root, 1);
         if (ret)
                 return ret;
         return 0;
@@ -635,7 +669,7 @@ int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root)
 {
-        return __btrfs_end_transaction(trans, root, 1, 1);
+        return __btrfs_end_transaction(trans, root, 1);
 }
 
 /*
@@ -649,13 +683,15 @@ int btrfs_write_marked_extents(struct btrfs_root *root,
         int err = 0;
         int werr = 0;
         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
+        struct extent_state *cached_state = NULL;
         u64 start = 0;
         u64 end;
 
         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
-                                      mark)) {
-                convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
-                                   GFP_NOFS);
+                                      mark, &cached_state)) {
+                convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
+                                   mark, &cached_state, GFP_NOFS);
+                cached_state = NULL;
                 err = filemap_fdatawrite_range(mapping, start, end);
                 if (err)
                         werr = err;
@@ -679,12 +715,14 @@ int btrfs_wait_marked_extents(struct btrfs_root *root,
         int err = 0;
         int werr = 0;
         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
+        struct extent_state *cached_state = NULL;
         u64 start = 0;
         u64 end;
 
         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
-                                      EXTENT_NEED_WAIT)) {
-                clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
+                                      EXTENT_NEED_WAIT, &cached_state)) {
+                clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
+                                 0, 0, &cached_state, GFP_NOFS);
                 err = filemap_fdatawait_range(mapping, start, end);
                 if (err)
                         werr = err;
@@ -809,7 +847,9 @@ static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
                 return ret;
 
         ret = btrfs_run_dev_stats(trans, root->fs_info);
-        BUG_ON(ret);
+        WARN_ON(ret);
+        ret = btrfs_run_dev_replace(trans, root->fs_info);
+        WARN_ON(ret);
 
         ret = btrfs_run_qgroups(trans, root->fs_info);
         BUG_ON(ret);
@@ -832,6 +872,8 @@ static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
         switch_commit_root(fs_info->extent_root);
         up_write(&fs_info->extent_commit_sem);
 
+        btrfs_after_dev_replace_commit(fs_info);
+
         return 0;
 }
 
@@ -916,7 +958,6 @@ int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
         struct btrfs_fs_info *info = root->fs_info;
         struct btrfs_trans_handle *trans;
         int ret;
-        unsigned long nr;
 
         if (xchg(&root->defrag_running, 1))
                 return 0;
@@ -928,9 +969,8 @@ int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
 
                 ret = btrfs_defrag_leaves(trans, root, cacheonly);
 
-                nr = trans->blocks_used;
                 btrfs_end_transaction(trans, root);
-                btrfs_btree_balance_dirty(info->tree_root, nr);
+                btrfs_btree_balance_dirty(info->tree_root);
                 cond_resched();
 
                 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
@@ -955,6 +995,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         struct btrfs_root *parent_root;
         struct btrfs_block_rsv *rsv;
         struct inode *parent_inode;
+        struct btrfs_path *path;
+        struct btrfs_dir_item *dir_item;
         struct dentry *parent;
         struct dentry *dentry;
         struct extent_buffer *tmp;
@@ -967,43 +1009,48 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         u64 root_flags;
         uuid_le new_uuid;
 
-        rsv = trans->block_rsv;
+        path = btrfs_alloc_path();
+        if (!path) {
+                ret = pending->error = -ENOMEM;
+                goto path_alloc_fail;
+        }
 
         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
         if (!new_root_item) {
                 ret = pending->error = -ENOMEM;
-                goto fail;
+                goto root_item_alloc_fail;
         }
 
         ret = btrfs_find_free_objectid(tree_root, &objectid);
         if (ret) {
                 pending->error = ret;
-                goto fail;
+                goto no_free_objectid;
         }
 
         btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
 
         if (to_reserve > 0) {
-                ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
-                                                  to_reserve);
+                ret = btrfs_block_rsv_add(root, &pending->block_rsv,
+                                          to_reserve,
+                                          BTRFS_RESERVE_NO_FLUSH);
                 if (ret) {
                         pending->error = ret;
-                        goto fail;
+                        goto no_free_objectid;
                 }
         }
 
         ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
                                    objectid, pending->inherit);
-        kfree(pending->inherit);
         if (ret) {
                 pending->error = ret;
-                goto fail;
+                goto no_free_objectid;
         }
 
         key.objectid = objectid;
         key.offset = (u64)-1;
         key.type = BTRFS_ROOT_ITEM_KEY;
 
+        rsv = trans->block_rsv;
         trans->block_rsv = &pending->block_rsv;
 
         dentry = pending->dentry;
@@ -1017,24 +1064,21 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
          */
         ret = btrfs_set_inode_index(parent_inode, &index);
         BUG_ON(ret); /* -ENOMEM */
-        ret = btrfs_insert_dir_item(trans, parent_root,
-                                dentry->d_name.name, dentry->d_name.len,
-                                parent_inode, &key,
-                                BTRFS_FT_DIR, index);
-        if (ret == -EEXIST) {
+
+        /* check if there is a file/dir which has the same name. */
+        dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
+                                         btrfs_ino(parent_inode),
+                                         dentry->d_name.name,
+                                         dentry->d_name.len, 0);
+        if (dir_item != NULL && !IS_ERR(dir_item)) {
                 pending->error = -EEXIST;
-                dput(parent);
                 goto fail;
-        } else if (ret) {
-                goto abort_trans_dput;
+        } else if (IS_ERR(dir_item)) {
+                ret = PTR_ERR(dir_item);
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
-
-        btrfs_i_size_write(parent_inode, parent_inode->i_size +
-                                         dentry->d_name.len * 2);
-        parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
-        ret = btrfs_update_inode(trans, parent_root, parent_inode);
-        if (ret)
-                goto abort_trans_dput;
+        btrfs_release_path(path);
 
         /*
          * pull in the delayed directory update
@@ -1043,8 +1087,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
          * snapshot
          */
         ret = btrfs_run_delayed_items(trans, root);
-        if (ret) { /* Transaction aborted */
-                dput(parent);
+        if (ret) {      /* Transaction aborted */
+                btrfs_abort_transaction(trans, root, ret);
                 goto fail;
         }
 
@@ -1079,7 +1123,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         if (ret) {
                 btrfs_tree_unlock(old);
                 free_extent_buffer(old);
-                goto abort_trans_dput;
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
 
         btrfs_set_lock_blocking(old);
@@ -1088,8 +1133,10 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         /* clean up in any case */
         btrfs_tree_unlock(old);
         free_extent_buffer(old);
-        if (ret)
-                goto abort_trans_dput;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
 
         /* see comments in should_cow_block() */
         root->force_cow = 1;
@@ -1101,8 +1148,10 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
         btrfs_tree_unlock(tmp);
         free_extent_buffer(tmp);
-        if (ret)
-                goto abort_trans_dput;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
 
         /*
          * insert root back/forward references
@@ -1111,32 +1160,58 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                                  parent_root->root_key.objectid,
                                  btrfs_ino(parent_inode), index,
                                  dentry->d_name.name, dentry->d_name.len);
-        dput(parent);
-        if (ret)
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
                 goto fail;
+        }
 
         key.offset = (u64)-1;
         pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
         if (IS_ERR(pending->snap)) {
                 ret = PTR_ERR(pending->snap);
-                goto abort_trans;
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
         }
 
         ret = btrfs_reloc_post_snapshot(trans, pending);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        ret = btrfs_insert_dir_item(trans, parent_root,
+                                    dentry->d_name.name, dentry->d_name.len,
+                                    parent_inode, &key,
+                                    BTRFS_FT_DIR, index);
+        /* We have check then name at the beginning, so it is impossible. */
+        BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
+        btrfs_i_size_write(parent_inode, parent_inode->i_size +
+                                         dentry->d_name.len * 2);
+        parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
+        ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
         if (ret)
-                goto abort_trans;
-        ret = 0;
+                btrfs_abort_transaction(trans, root, ret);
 fail:
-        kfree(new_root_item);
+        dput(parent);
         trans->block_rsv = rsv;
+no_free_objectid:
+        kfree(new_root_item);
+root_item_alloc_fail:
+        btrfs_free_path(path);
+path_alloc_fail:
         btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
         return ret;
-
-abort_trans_dput:
-        dput(parent);
-abort_trans:
-        btrfs_abort_transaction(trans, root, ret);
-        goto fail;
 }
 
 /*
@@ -1229,6 +1304,17 @@ static void do_async_commit(struct work_struct *work)
         struct btrfs_async_commit *ac =
                 container_of(work, struct btrfs_async_commit, work.work);
 
+        /*
+         * We've got freeze protection passed with the transaction.
+         * Tell lockdep about it.
+         */
+        if (ac->newtrans->type < TRANS_JOIN_NOLOCK)
+                rwsem_acquire_read(
+                     &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
+                     0, 1, _THIS_IP_);
+
+        current->journal_info = ac->newtrans;
+
         btrfs_commit_transaction(ac->newtrans, ac->root);
         kfree(ac);
 }
@@ -1258,6 +1344,16 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
         atomic_inc(&cur_trans->use_count);
 
         btrfs_end_transaction(trans, root);
+
+        /*
+         * 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)
+                rwsem_release(
+                        &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
+                        1, _THIS_IP_);
+
         schedule_delayed_work(&ac->work, 0);
 
         /* wait for transaction to start and unblock */
@@ -1306,6 +1402,48 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans,
         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 }
 
+static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
+                                          struct btrfs_root *root)
+{
+        int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
+        int snap_pending = 0;
+        int ret;
+
+        if (!flush_on_commit) {
+                spin_lock(&root->fs_info->trans_lock);
+                if (!list_empty(&trans->transaction->pending_snapshots))
+                        snap_pending = 1;
+                spin_unlock(&root->fs_info->trans_lock);
+        }
+
+        if (flush_on_commit || snap_pending) {
+                btrfs_start_delalloc_inodes(root, 1);
+                btrfs_wait_ordered_extents(root, 1);
+        }
+
+        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);
+
+        /*
+         * rename don't use btrfs_join_transaction, so, once we
+         * set the transaction to blocked above, we aren't going
+         * to get any new ordered operations.  We can safely run
+         * it here and no for sure that nothing new will be added
+         * to the list
+         */
+        btrfs_run_ordered_operations(root, 1);
+
+        return 0;
+}
+
 /*
  * btrfs_transaction state sequence:
  *    in_commit = 0, blocked = 0  (initial)
@@ -1320,15 +1458,20 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         struct btrfs_transaction *cur_trans = trans->transaction;
         struct btrfs_transaction *prev_trans = NULL;
         DEFINE_WAIT(wait);
-        int ret = -EIO;
+        int ret;
         int should_grow = 0;
         unsigned long now = get_seconds();
-        int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
 
-        btrfs_run_ordered_operations(root, 0);
+        ret = btrfs_run_ordered_operations(root, 0);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto cleanup_transaction;
+        }
 
-        if (cur_trans->aborted)
+        if (cur_trans->aborted) {
+                ret = cur_trans->aborted;
                 goto cleanup_transaction;
+        }
 
         /* make a pass through all the delayed refs we have so far
          * any runnings procs may add more while we are here
@@ -1348,6 +1491,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          */
         cur_trans->delayed_refs.flushing = 1;
 
+        if (!list_empty(&trans->new_bgs))
+                btrfs_create_pending_block_groups(trans, root);
+
         ret = btrfs_run_delayed_refs(trans, root, 0);
         if (ret)
                 goto cleanup_transaction;
@@ -1393,39 +1539,14 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
                 should_grow = 1;
 
         do {
-                int snap_pending = 0;
-
                 joined = cur_trans->num_joined;
-                if (!list_empty(&trans->transaction->pending_snapshots))
-                        snap_pending = 1;
 
                 WARN_ON(cur_trans != trans->transaction);
 
-                if (flush_on_commit || snap_pending) {
-                        btrfs_start_delalloc_inodes(root, 1);
-                        btrfs_wait_ordered_extents(root, 0, 1);
-                }
-
-                ret = btrfs_run_delayed_items(trans, root);
+                ret = btrfs_flush_all_pending_stuffs(trans, root);
                 if (ret)
                         goto cleanup_transaction;
 
-                /*
-                 * 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);
-
-                /*
-                 * rename don't use btrfs_join_transaction, so, once we
-                 * set the transaction to blocked above, we aren't going
-                 * to get any new ordered operations.  We can safely run
-                 * it here and no for sure that nothing new will be added
-                 * to the list
-                 */
-                btrfs_run_ordered_operations(root, 1);
-
                 prepare_to_wait(&cur_trans->writer_wait, &wait,
                                 TASK_UNINTERRUPTIBLE);
 
@@ -1438,6 +1559,10 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         } while (atomic_read(&cur_trans->num_writers) > 1 ||
                  (should_grow && cur_trans->num_joined != joined));
 
+        ret = btrfs_flush_all_pending_stuffs(trans, root);
+        if (ret)
+                goto cleanup_transaction;
+
         /*
          * Ok now we need to make sure to block out any other joins while we
          * commit the transaction.  We could have started a join before setting
@@ -1456,13 +1581,28 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
          */
         mutex_lock(&root->fs_info->reloc_mutex);
 
-        ret = btrfs_run_delayed_items(trans, root);
+        /*
+         * We needn't worry about the delayed items because we will
+         * deal with them in create_pending_snapshot(), which is the
+         * core function of the snapshot creation.
+         */
+        ret = create_pending_snapshots(trans, root->fs_info);
         if (ret) {
                 mutex_unlock(&root->fs_info->reloc_mutex);
                 goto cleanup_transaction;
         }
 
-        ret = create_pending_snapshots(trans, root->fs_info);
+        /*
+         * We insert the dir indexes of the snapshots and update the inode
+         * of the snapshots' parents after the snapshot creation, so there
+         * are some delayed items which are not dealt with. Now deal with
+         * them.
+         *
+         * We needn't worry that this operation will corrupt the snapshots,
+         * because all the tree which are snapshoted will be forced to COW
+         * the nodes and leaves.
+         */
+        ret = btrfs_run_delayed_items(trans, root);
         if (ret) {
                 mutex_unlock(&root->fs_info->reloc_mutex);
                 goto cleanup_transaction;
@@ -1584,7 +1724,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         put_transaction(cur_trans);
         put_transaction(cur_trans);
 
-        sb_end_intwrite(root->fs_info->sb);
+        if (trans->type < TRANS_JOIN_NOLOCK)
+                sb_end_intwrite(root->fs_info->sb);
 
         trace_btrfs_transaction_commit(root);
 
diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index e8b8416c688b..0e8aa1e6c287 100644
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -47,6 +47,14 @@ struct btrfs_transaction {
         int aborted;
 };
 
+enum btrfs_trans_type {
+        TRANS_START,
+        TRANS_JOIN,
+        TRANS_USERSPACE,
+        TRANS_JOIN_NOLOCK,
+        TRANS_ATTACH,
+};
+
 struct btrfs_trans_handle {
         u64 transid;
         u64 bytes_reserved;
@@ -58,8 +66,9 @@ struct btrfs_trans_handle {
         struct btrfs_transaction *transaction;
         struct btrfs_block_rsv *block_rsv;
         struct btrfs_block_rsv *orig_rsv;
-        int aborted;
-        int adding_csums;
+        short aborted;
+        short adding_csums;
+        enum btrfs_trans_type type;
         /*
          * this root is only needed to validate that the root passed to
          * start_transaction is the same as the one passed to end_transaction.
@@ -68,6 +77,7 @@ struct btrfs_trans_handle {
         struct btrfs_root *root;
         struct seq_list delayed_ref_elem;
         struct list_head qgroup_ref_list;
+        struct list_head new_bgs;
 };
 
 struct btrfs_pending_snapshot {
@@ -88,16 +98,18 @@ static inline void btrfs_set_inode_last_trans(struct btrfs_trans_handle *trans,
 {
         BTRFS_I(inode)->last_trans = trans->transaction->transid;
         BTRFS_I(inode)->last_sub_trans = BTRFS_I(inode)->root->log_transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->root->last_log_commit;
 }
 
 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
                           struct btrfs_root *root);
-int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
-                                 struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                    int num_items);
+struct btrfs_trans_handle *btrfs_start_transaction_lflush(
+                                        struct btrfs_root *root, int num_items);
 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root);
+struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root);
 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root);
 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid);
 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index c86670f4f285..83186c7e45d4 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -18,13 +18,16 @@
 
 #include <linux/sched.h>
 #include <linux/slab.h>
+#include <linux/list_sort.h>
 #include "ctree.h"
 #include "transaction.h"
 #include "disk-io.h"
 #include "locking.h"
 #include "print-tree.h"
+#include "backref.h"
 #include "compat.h"
 #include "tree-log.h"
+#include "hash.h"
 
 /* magic values for the inode_only field in btrfs_log_inode:
  *
@@ -146,7 +149,7 @@ static int start_log_trans(struct btrfs_trans_handle *trans,
                         root->log_multiple_pids = true;
                 }
 
-                root->log_batch++;
+                atomic_inc(&root->log_batch);
                 atomic_inc(&root->log_writers);
                 mutex_unlock(&root->log_mutex);
                 return 0;
@@ -165,7 +168,7 @@ static int start_log_trans(struct btrfs_trans_handle *trans,
                         err = ret;
         }
         mutex_unlock(&root->fs_info->tree_log_mutex);
-        root->log_batch++;
+        atomic_inc(&root->log_batch);
         atomic_inc(&root->log_writers);
         mutex_unlock(&root->log_mutex);
         return err;
@@ -484,7 +487,6 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
         int found_type;
         u64 mask = root->sectorsize - 1;
         u64 extent_end;
-        u64 alloc_hint;
         u64 start = key->offset;
         u64 saved_nbytes;
         struct btrfs_file_extent_item *item;
@@ -550,8 +552,7 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
 
         saved_nbytes = inode_get_bytes(inode);
         /* drop any overlapping extents */
-        ret = btrfs_drop_extents(trans, inode, start, extent_end,
-                                 &alloc_hint, 1);
+        ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
         BUG_ON(ret);
 
         if (found_type == BTRFS_FILE_EXTENT_REG ||
@@ -744,6 +745,7 @@ out:
  */
 static noinline int backref_in_log(struct btrfs_root *log,
                                    struct btrfs_key *key,
+                                   u64 ref_objectid,
                                    char *name, int namelen)
 {
         struct btrfs_path *path;
@@ -764,8 +766,17 @@ static noinline int backref_in_log(struct btrfs_root *log,
         if (ret != 0)
                 goto out;
 
-        item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
         ptr = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
+
+        if (key->type == BTRFS_INODE_EXTREF_KEY) {
+                if (btrfs_find_name_in_ext_backref(path, ref_objectid,
+                                                   name, namelen, NULL))
+                        match = 1;
+
+                goto out;
+        }
+
+        item_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]);
         ptr_end = ptr + item_size;
         while (ptr < ptr_end) {
                 ref = (struct btrfs_inode_ref *)ptr;
@@ -786,91 +797,42 @@ out:
         return match;
 }
 
-
-/*
- * replay one inode back reference item found in the log tree.
- * eb, slot and key refer to the buffer and key found in the log tree.
- * root is the destination we are replaying into, and path is for temp
- * use by this function.  (it should be released on return).
- */
-static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
+static inline int __add_inode_ref(struct btrfs_trans_handle *trans,
                                   struct btrfs_root *root,
-                                  struct btrfs_root *log,
                                   struct btrfs_path *path,
-                                  struct extent_buffer *eb, int slot,
-                                  struct btrfs_key *key)
+                                  struct btrfs_root *log_root,
+                                  struct inode *dir, struct inode *inode,
+                                  struct extent_buffer *eb,
+                                  u64 inode_objectid, u64 parent_objectid,
+                                  u64 ref_index, char *name, int namelen,
+                                  int *search_done)
 {
-        struct btrfs_inode_ref *ref;
-        struct btrfs_dir_item *di;
-        struct inode *dir;
-        struct inode *inode;
-        unsigned long ref_ptr;
-        unsigned long ref_end;
-        char *name;
-        int namelen;
         int ret;
-        int search_done = 0;
-
-        /*
-         * it is possible that we didn't log all the parent directories
-         * for a given inode.  If we don't find the dir, just don't
-         * copy the back ref in.  The link count fixup code will take
-         * care of the rest
-         */
-        dir = read_one_inode(root, key->offset);
-        if (!dir)
-                return -ENOENT;
-
-        inode = read_one_inode(root, key->objectid);
-        if (!inode) {
-                iput(dir);
-                return -EIO;
-        }
-
-        ref_ptr = btrfs_item_ptr_offset(eb, slot);
-        ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
+        char *victim_name;
+        int victim_name_len;
+        struct extent_buffer *leaf;
+        struct btrfs_dir_item *di;
+        struct btrfs_key search_key;
+        struct btrfs_inode_extref *extref;
 
 again:
-        ref = (struct btrfs_inode_ref *)ref_ptr;
-
-        namelen = btrfs_inode_ref_name_len(eb, ref);
-        name = kmalloc(namelen, GFP_NOFS);
-        BUG_ON(!name);
-
-        read_extent_buffer(eb, name, (unsigned long)(ref + 1), namelen);
-
-        /* if we already have a perfect match, we're done */
-        if (inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
-                         btrfs_inode_ref_index(eb, ref),
-                         name, namelen)) {
-                goto out;
-        }
-
-        /*
-         * look for a conflicting back reference in the metadata.
-         * if we find one we have to unlink that name of the file
-         * before we add our new link.  Later on, we overwrite any
-         * existing back reference, and we don't want to create
-         * dangling pointers in the directory.
-         */
-
-        if (search_done)
-                goto insert;
-
-        ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
+        /* Search old style refs */
+        search_key.objectid = inode_objectid;
+        search_key.type = BTRFS_INODE_REF_KEY;
+        search_key.offset = parent_objectid;
+        ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
         if (ret == 0) {
-                char *victim_name;
-                int victim_name_len;
                 struct btrfs_inode_ref *victim_ref;
                 unsigned long ptr;
                 unsigned long ptr_end;
-                struct extent_buffer *leaf = path->nodes[0];
+
+                leaf = path->nodes[0];
 
                 /* are we trying to overwrite a back ref for the root directory
                  * if so, just jump out, we're done
                  */
-                if (key->objectid == key->offset)
-                        goto out_nowrite;
+                if (search_key.objectid == search_key.offset)
+                        return 1;
 
                 /* check all the names in this back reference to see
                  * if they are in the log.  if so, we allow them to stay
@@ -889,7 +851,9 @@ again:
                                            (unsigned long)(victim_ref + 1),
                                            victim_name_len);
 
-                        if (!backref_in_log(log, key, victim_name,
+                        if (!backref_in_log(log_root, &search_key,
+                                            parent_objectid,
+                                            victim_name,
                                             victim_name_len)) {
                                 btrfs_inc_nlink(inode);
                                 btrfs_release_path(path);
@@ -897,9 +861,14 @@ again:
                                 ret = btrfs_unlink_inode(trans, root, dir,
                                                          inode, victim_name,
                                                          victim_name_len);
+                                BUG_ON(ret);
                                 btrfs_run_delayed_items(trans, root);
+                                kfree(victim_name);
+                                *search_done = 1;
+                                goto again;
                         }
                         kfree(victim_name);
+
                         ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
                 }
                 BUG_ON(ret);
@@ -908,14 +877,78 @@ again:
                  * NOTE: we have searched root tree and checked the
                  * coresponding ref, it does not need to check again.
                  */
-                search_done = 1;
+                *search_done = 1;
+        }
+        btrfs_release_path(path);
+
+        /* Same search but for extended refs */
+        extref = btrfs_lookup_inode_extref(NULL, root, path, name, namelen,
+                                           inode_objectid, parent_objectid, 0,
+                                           0);
+        if (!IS_ERR_OR_NULL(extref)) {
+                u32 item_size;
+                u32 cur_offset = 0;
+                unsigned long base;
+                struct inode *victim_parent;
+
+                leaf = path->nodes[0];
+
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                base = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+                while (cur_offset < item_size) {
+                        extref = (struct btrfs_inode_extref *)base + cur_offset;
+
+                        victim_name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                        if (btrfs_inode_extref_parent(leaf, extref) != parent_objectid)
+                                goto next;
+
+                        victim_name = kmalloc(victim_name_len, GFP_NOFS);
+                        read_extent_buffer(leaf, victim_name, (unsigned long)&extref->name,
+                                           victim_name_len);
+
+                        search_key.objectid = inode_objectid;
+                        search_key.type = BTRFS_INODE_EXTREF_KEY;
+                        search_key.offset = btrfs_extref_hash(parent_objectid,
+                                                              victim_name,
+                                                              victim_name_len);
+                        ret = 0;
+                        if (!backref_in_log(log_root, &search_key,
+                                            parent_objectid, victim_name,
+                                            victim_name_len)) {
+                                ret = -ENOENT;
+                                victim_parent = read_one_inode(root,
+                                                               parent_objectid);
+                                if (victim_parent) {
+                                        btrfs_inc_nlink(inode);
+                                        btrfs_release_path(path);
+
+                                        ret = btrfs_unlink_inode(trans, root,
+                                                                 victim_parent,
+                                                                 inode,
+                                                                 victim_name,
+                                                                 victim_name_len);
+                                        btrfs_run_delayed_items(trans, root);
+                                }
+                                BUG_ON(ret);
+                                iput(victim_parent);
+                                kfree(victim_name);
+                                *search_done = 1;
+                                goto again;
+                        }
+                        kfree(victim_name);
+                        BUG_ON(ret);
+next:
+                        cur_offset += victim_name_len + sizeof(*extref);
+                }
+                *search_done = 1;
         }
         btrfs_release_path(path);
 
         /* look for a conflicting sequence number */
         di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir),
-                                         btrfs_inode_ref_index(eb, ref),
-                                         name, namelen, 0);
+                                         ref_index, name, namelen, 0);
         if (di && !IS_ERR(di)) {
                 ret = drop_one_dir_item(trans, root, path, dir, di);
                 BUG_ON(ret);
@@ -931,25 +964,173 @@ again:
         }
         btrfs_release_path(path);
 
-insert:
-        /* insert our name */
-        ret = btrfs_add_link(trans, dir, inode, name, namelen, 0,
-                             btrfs_inode_ref_index(eb, ref));
-        BUG_ON(ret);
+        return 0;
+}
 
-        btrfs_update_inode(trans, root, inode);
+static int extref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
+                             u32 *namelen, char **name, u64 *index,
+                             u64 *parent_objectid)
+{
+        struct btrfs_inode_extref *extref;
 
-out:
-        ref_ptr = (unsigned long)(ref + 1) + namelen;
-        kfree(name);
-        if (ref_ptr < ref_end)
-                goto again;
+        extref = (struct btrfs_inode_extref *)ref_ptr;
+
+        *namelen = btrfs_inode_extref_name_len(eb, extref);
+        *name = kmalloc(*namelen, GFP_NOFS);
+        if (*name == NULL)
+                return -ENOMEM;
+
+        read_extent_buffer(eb, *name, (unsigned long)&extref->name,
+                           *namelen);
+
+        *index = btrfs_inode_extref_index(eb, extref);
+        if (parent_objectid)
+                *parent_objectid = btrfs_inode_extref_parent(eb, extref);
+
+        return 0;
+}
+
+static int ref_get_fields(struct extent_buffer *eb, unsigned long ref_ptr,
+                          u32 *namelen, char **name, u64 *index)
+{
+        struct btrfs_inode_ref *ref;
+
+        ref = (struct btrfs_inode_ref *)ref_ptr;
+
+        *namelen = btrfs_inode_ref_name_len(eb, ref);
+        *name = kmalloc(*namelen, GFP_NOFS);
+        if (*name == NULL)
+                return -ENOMEM;
+
+        read_extent_buffer(eb, *name, (unsigned long)(ref + 1), *namelen);
+
+        *index = btrfs_inode_ref_index(eb, ref);
+
+        return 0;
+}
+
+/*
+ * replay one inode back reference item found in the log tree.
+ * eb, slot and key refer to the buffer and key found in the log tree.
+ * root is the destination we are replaying into, and path is for temp
+ * use by this function.  (it should be released on return).
+ */
+static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
+                                  struct btrfs_root *root,
+                                  struct btrfs_root *log,
+                                  struct btrfs_path *path,
+                                  struct extent_buffer *eb, int slot,
+                                  struct btrfs_key *key)
+{
+        struct inode *dir;
+        struct inode *inode;
+        unsigned long ref_ptr;
+        unsigned long ref_end;
+        char *name;
+        int namelen;
+        int ret;
+        int search_done = 0;
+        int log_ref_ver = 0;
+        u64 parent_objectid;
+        u64 inode_objectid;
+        u64 ref_index = 0;
+        int ref_struct_size;
+
+        ref_ptr = btrfs_item_ptr_offset(eb, slot);
+        ref_end = ref_ptr + btrfs_item_size_nr(eb, slot);
+
+        if (key->type == BTRFS_INODE_EXTREF_KEY) {
+                struct btrfs_inode_extref *r;
+
+                ref_struct_size = sizeof(struct btrfs_inode_extref);
+                log_ref_ver = 1;
+                r = (struct btrfs_inode_extref *)ref_ptr;
+                parent_objectid = btrfs_inode_extref_parent(eb, r);
+        } else {
+                ref_struct_size = sizeof(struct btrfs_inode_ref);
+                parent_objectid = key->offset;
+        }
+        inode_objectid = key->objectid;
+
+        /*
+         * it is possible that we didn't log all the parent directories
+         * for a given inode.  If we don't find the dir, just don't
+         * copy the back ref in.  The link count fixup code will take
+         * care of the rest
+         */
+        dir = read_one_inode(root, parent_objectid);
+        if (!dir)
+                return -ENOENT;
+
+        inode = read_one_inode(root, inode_objectid);
+        if (!inode) {
+                iput(dir);
+                return -EIO;
+        }
+
+        while (ref_ptr < ref_end) {
+                if (log_ref_ver) {
+                        ret = extref_get_fields(eb, ref_ptr, &namelen, &name,
+                                                &ref_index, &parent_objectid);
+                        /*
+                         * parent object can change from one array
+                         * item to another.
+                         */
+                        if (!dir)
+                                dir = read_one_inode(root, parent_objectid);
+                        if (!dir)
+                                return -ENOENT;
+                } else {
+                        ret = ref_get_fields(eb, ref_ptr, &namelen, &name,
+                                             &ref_index);
+                }
+                if (ret)
+                        return ret;
+
+                /* if we already have a perfect match, we're done */
+                if (!inode_in_dir(root, path, btrfs_ino(dir), btrfs_ino(inode),
+                                  ref_index, name, namelen)) {
+                        /*
+                         * look for a conflicting back reference in the
+                         * metadata. if we find one we have to unlink that name
+                         * of the file before we add our new link.  Later on, we
+                         * overwrite any existing back reference, and we don't
+                         * want to create dangling pointers in the directory.
+                         */
+
+                        if (!search_done) {
+                                ret = __add_inode_ref(trans, root, path, log,
+                                                      dir, inode, eb,
+                                                      inode_objectid,
+                                                      parent_objectid,
+                                                      ref_index, name, namelen,
+                                                      &search_done);
+                                if (ret == 1)
+                                        goto out;
+                                BUG_ON(ret);
+                        }
+
+                        /* insert our name */
+                        ret = btrfs_add_link(trans, dir, inode, name, namelen,
+                                             0, ref_index);
+                        BUG_ON(ret);
+
+                        btrfs_update_inode(trans, root, inode);
+                }
+
+                ref_ptr = (unsigned long)(ref_ptr + ref_struct_size) + namelen;
+                kfree(name);
+                if (log_ref_ver) {
+                        iput(dir);
+                        dir = NULL;
+                }
+        }
 
         /* finally write the back reference in the inode */
         ret = overwrite_item(trans, root, path, eb, slot, key);
         BUG_ON(ret);
 
-out_nowrite:
+out:
         btrfs_release_path(path);
         iput(dir);
         iput(inode);
@@ -966,25 +1147,55 @@ static int insert_orphan_item(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static int count_inode_extrefs(struct btrfs_root *root,
+                               struct inode *inode, struct btrfs_path *path)
+{
+        int ret = 0;
+        int name_len;
+        unsigned int nlink = 0;
+        u32 item_size;
+        u32 cur_offset = 0;
+        u64 inode_objectid = btrfs_ino(inode);
+        u64 offset = 0;
+        unsigned long ptr;
+        struct btrfs_inode_extref *extref;
+        struct extent_buffer *leaf;
 
-/*
- * There are a few corners where the link count of the file can't
- * be properly maintained during replay.  So, instead of adding
- * lots of complexity to the log code, we just scan the backrefs
- * for any file that has been through replay.
- *
- * The scan will update the link count on the inode to reflect the
- * number of back refs found.  If it goes down to zero, the iput
- * will free the inode.
- */
-static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
-                                           struct btrfs_root *root,
-                                           struct inode *inode)
+        while (1) {
+                ret = btrfs_find_one_extref(root, inode_objectid, offset, path,
+                                            &extref, &offset);
+                if (ret)
+                        break;
+
+                leaf = path->nodes[0];
+                item_size = btrfs_item_size_nr(leaf, path->slots[0]);
+                ptr = btrfs_item_ptr_offset(leaf, path->slots[0]);
+
+                while (cur_offset < item_size) {
+                        extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
+                        name_len = btrfs_inode_extref_name_len(leaf, extref);
+
+                        nlink++;
+
+                        cur_offset += name_len + sizeof(*extref);
+                }
+
+                offset++;
+                btrfs_release_path(path);
+        }
+        btrfs_release_path(path);
+
+        if (ret < 0)
+                return ret;
+        return nlink;
+}
+
+static int count_inode_refs(struct btrfs_root *root,
+                               struct inode *inode, struct btrfs_path *path)
 {
-        struct btrfs_path *path;
         int ret;
         struct btrfs_key key;
-        u64 nlink = 0;
+        unsigned int nlink = 0;
         unsigned long ptr;
         unsigned long ptr_end;
         int name_len;
@@ -994,10 +1205,6 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
         key.type = BTRFS_INODE_REF_KEY;
         key.offset = (u64)-1;
 
-        path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
-
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
@@ -1031,6 +1238,50 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
                 btrfs_release_path(path);
         }
         btrfs_release_path(path);
+
+        return nlink;
+}
+
+/*
+ * There are a few corners where the link count of the file can't
+ * be properly maintained during replay.  So, instead of adding
+ * lots of complexity to the log code, we just scan the backrefs
+ * for any file that has been through replay.
+ *
+ * The scan will update the link count on the inode to reflect the
+ * number of back refs found.  If it goes down to zero, the iput
+ * will free the inode.
+ */
+static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
+                                           struct btrfs_root *root,
+                                           struct inode *inode)
+{
+        struct btrfs_path *path;
+        int ret;
+        u64 nlink = 0;
+        u64 ino = btrfs_ino(inode);
+
+        path = btrfs_alloc_path();
+        if (!path)
+                return -ENOMEM;
+
+        ret = count_inode_refs(root, inode, path);
+        if (ret < 0)
+                goto out;
+
+        nlink = ret;
+
+        ret = count_inode_extrefs(root, inode, path);
+        if (ret == -ENOENT)
+                ret = 0;
+
+        if (ret < 0)
+                goto out;
+
+        nlink += ret;
+
+        ret = 0;
+
         if (nlink != inode->i_nlink) {
                 set_nlink(inode, nlink);
                 btrfs_update_inode(trans, root, inode);
@@ -1046,9 +1297,10 @@ static noinline int fixup_inode_link_count(struct btrfs_trans_handle *trans,
                 ret = insert_orphan_item(trans, root, ino);
                 BUG_ON(ret);
         }
-        btrfs_free_path(path);
 
-        return 0;
+out:
+        btrfs_free_path(path);
+        return ret;
 }
 
 static noinline int fixup_inode_link_counts(struct btrfs_trans_handle *trans,
@@ -1695,6 +1947,10 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                         ret = add_inode_ref(wc->trans, root, log, path,
                                             eb, i, &key);
                         BUG_ON(ret && ret != -ENOENT);
+                } else if (key.type == BTRFS_INODE_EXTREF_KEY) {
+                        ret = add_inode_ref(wc->trans, root, log, path,
+                                            eb, i, &key);
+                        BUG_ON(ret && ret != -ENOENT);
                 } else if (key.type == BTRFS_EXTENT_DATA_KEY) {
                         ret = replay_one_extent(wc->trans, root, path,
                                                 eb, i, &key);
@@ -2037,7 +2293,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
                 wait_log_commit(trans, root, root->log_transid - 1);
         while (1) {
-                unsigned long batch = root->log_batch;
+                int batch = atomic_read(&root->log_batch);
                 /* when we're on an ssd, just kick the log commit out */
                 if (!btrfs_test_opt(root, SSD) && root->log_multiple_pids) {
                         mutex_unlock(&root->log_mutex);
@@ -2045,7 +2301,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
                         mutex_lock(&root->log_mutex);
                 }
                 wait_for_writer(trans, root);
-                if (batch == root->log_batch)
+                if (batch == atomic_read(&root->log_batch))
                         break;
         }
 
@@ -2074,7 +2330,6 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
 
         btrfs_set_root_node(&log->root_item, log->node);
 
-        root->log_batch = 0;
         root->log_transid++;
         log->log_transid = root->log_transid;
         root->log_start_pid = 0;
@@ -2087,7 +2342,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         mutex_unlock(&root->log_mutex);
 
         mutex_lock(&log_root_tree->log_mutex);
-        log_root_tree->log_batch++;
+        atomic_inc(&log_root_tree->log_batch);
         atomic_inc(&log_root_tree->log_writers);
         mutex_unlock(&log_root_tree->log_mutex);
 
@@ -2157,7 +2412,6 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
         btrfs_set_super_log_root_level(root->fs_info->super_for_commit,
                                 btrfs_header_level(log_root_tree->node));
 
-        log_root_tree->log_batch = 0;
         log_root_tree->log_transid++;
         smp_mb();
 
@@ -2171,9 +2425,12 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
          * in and cause problems either.
          */
         btrfs_scrub_pause_super(root);
-        write_ctree_super(trans, root->fs_info->tree_root, 1);
+        ret = write_ctree_super(trans, root->fs_info->tree_root, 1);
         btrfs_scrub_continue_super(root);
-        ret = 0;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out_wake_log_root;
+        }
 
         mutex_lock(&root->log_mutex);
         if (root->last_log_commit < log_transid)
@@ -2209,7 +2466,8 @@ static void free_log_tree(struct btrfs_trans_handle *trans,
 
         while (1) {
                 ret = find_first_extent_bit(&log->dirty_log_pages,
-                                0, &start, &end, EXTENT_DIRTY | EXTENT_NEW);
+                                0, &start, &end, EXTENT_DIRTY | EXTENT_NEW,
+                                NULL);
                 if (ret)
                         break;
 
@@ -2646,6 +2904,7 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
         int ret;
         struct btrfs_key key;
         struct btrfs_key found_key;
+        int start_slot;
 
         key.objectid = objectid;
         key.type = max_key_type;
@@ -2667,8 +2926,18 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
                 if (found_key.objectid != objectid)
                         break;
 
-                ret = btrfs_del_item(trans, log, path);
-                if (ret)
+                found_key.offset = 0;
+                found_key.type = 0;
+                ret = btrfs_bin_search(path->nodes[0], &found_key, 0,
+                                       &start_slot);
+
+                ret = btrfs_del_items(trans, log, path, start_slot,
+                                      path->slots[0] - start_slot + 1);
+                /*
+                 * If start slot isn't 0 then we don't need to re-search, we've
+                 * found the last guy with the objectid in this tree.
+                 */
+                if (ret || start_slot != 0)
                         break;
                 btrfs_release_path(path);
         }
@@ -2678,14 +2947,89 @@ static int drop_objectid_items(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static void fill_inode_item(struct btrfs_trans_handle *trans,
+                            struct extent_buffer *leaf,
+                            struct btrfs_inode_item *item,
+                            struct inode *inode, int log_inode_only)
+{
+        struct btrfs_map_token token;
+
+        btrfs_init_map_token(&token);
+
+        if (log_inode_only) {
+                /* set the generation to zero so the recover code
+                 * can tell the difference between an logging
+                 * just to say 'this inode exists' and a logging
+                 * to say 'update this inode with these values'
+                 */
+                btrfs_set_token_inode_generation(leaf, item, 0, &token);
+                btrfs_set_token_inode_size(leaf, item, 0, &token);
+        } else {
+                btrfs_set_token_inode_generation(leaf, item,
+                                                 BTRFS_I(inode)->generation,
+                                                 &token);
+                btrfs_set_token_inode_size(leaf, item, inode->i_size, &token);
+        }
+
+        btrfs_set_token_inode_uid(leaf, item, i_uid_read(inode), &token);
+        btrfs_set_token_inode_gid(leaf, item, i_gid_read(inode), &token);
+        btrfs_set_token_inode_mode(leaf, item, inode->i_mode, &token);
+        btrfs_set_token_inode_nlink(leaf, item, inode->i_nlink, &token);
+
+        btrfs_set_token_timespec_sec(leaf, btrfs_inode_atime(item),
+                                     inode->i_atime.tv_sec, &token);
+        btrfs_set_token_timespec_nsec(leaf, btrfs_inode_atime(item),
+                                      inode->i_atime.tv_nsec, &token);
+
+        btrfs_set_token_timespec_sec(leaf, btrfs_inode_mtime(item),
+                                     inode->i_mtime.tv_sec, &token);
+        btrfs_set_token_timespec_nsec(leaf, btrfs_inode_mtime(item),
+                                      inode->i_mtime.tv_nsec, &token);
+
+        btrfs_set_token_timespec_sec(leaf, btrfs_inode_ctime(item),
+                                     inode->i_ctime.tv_sec, &token);
+        btrfs_set_token_timespec_nsec(leaf, btrfs_inode_ctime(item),
+                                      inode->i_ctime.tv_nsec, &token);
+
+        btrfs_set_token_inode_nbytes(leaf, item, inode_get_bytes(inode),
+                                     &token);
+
+        btrfs_set_token_inode_sequence(leaf, item, inode->i_version, &token);
+        btrfs_set_token_inode_transid(leaf, item, trans->transid, &token);
+        btrfs_set_token_inode_rdev(leaf, item, inode->i_rdev, &token);
+        btrfs_set_token_inode_flags(leaf, item, BTRFS_I(inode)->flags, &token);
+        btrfs_set_token_inode_block_group(leaf, item, 0, &token);
+}
+
+static int log_inode_item(struct btrfs_trans_handle *trans,
+                          struct btrfs_root *log, struct btrfs_path *path,
+                          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, &key,
+                                      sizeof(*inode_item));
+        if (ret && ret != -EEXIST)
+                return ret;
+        inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
+                                    struct btrfs_inode_item);
+        fill_inode_item(trans, path->nodes[0], inode_item, inode, 0);
+        btrfs_release_path(path);
+        return 0;
+}
+
 static noinline int copy_items(struct btrfs_trans_handle *trans,
-                               struct btrfs_root *log,
+                               struct inode *inode,
                                struct btrfs_path *dst_path,
                                struct extent_buffer *src,
                                int start_slot, int nr, int inode_only)
 {
         unsigned long src_offset;
         unsigned long dst_offset;
+        struct btrfs_root *log = BTRFS_I(inode)->root->log_root;
         struct btrfs_file_extent_item *extent;
         struct btrfs_inode_item *inode_item;
         int ret;
@@ -2694,6 +3038,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
         char *ins_data;
         int i;
         struct list_head ordered_sums;
+        int skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         INIT_LIST_HEAD(&ordered_sums);
 
@@ -2722,29 +3067,23 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
 
                 src_offset = btrfs_item_ptr_offset(src, start_slot + i);
 
-                copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
-                                   src_offset, ins_sizes[i]);
-
-                if (inode_only == LOG_INODE_EXISTS &&
-                    ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
+                if (ins_keys[i].type == BTRFS_INODE_ITEM_KEY) {
                         inode_item = btrfs_item_ptr(dst_path->nodes[0],
                                                     dst_path->slots[0],
                                                     struct btrfs_inode_item);
-                        btrfs_set_inode_size(dst_path->nodes[0], inode_item, 0);
-
-                        /* set the generation to zero so the recover code
-                         * can tell the difference between an logging
-                         * just to say 'this inode exists' and a logging
-                         * to say 'update this inode with these values'
-                         */
-                        btrfs_set_inode_generation(dst_path->nodes[0],
-                                                   inode_item, 0);
+                        fill_inode_item(trans, dst_path->nodes[0], inode_item,
+                                        inode, inode_only == LOG_INODE_EXISTS);
+                } else {
+                        copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
+                                           src_offset, ins_sizes[i]);
                 }
+
                 /* take a reference on file data extents so that truncates
                  * or deletes of this inode don't have to relog the inode
                  * again
                  */
-                if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY) {
+                if (btrfs_key_type(ins_keys + i) == BTRFS_EXTENT_DATA_KEY &&
+                    !skip_csum) {
                         int found_type;
                         extent = btrfs_item_ptr(src, start_slot + i,
                                                 struct btrfs_file_extent_item);
@@ -2753,8 +3092,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
                                 continue;
 
                         found_type = btrfs_file_extent_type(src, extent);
-                        if (found_type == BTRFS_FILE_EXTENT_REG ||
-                            found_type == BTRFS_FILE_EXTENT_PREALLOC) {
+                        if (found_type == BTRFS_FILE_EXTENT_REG) {
                                 u64 ds, dl, cs, cl;
                                 ds = btrfs_file_extent_disk_bytenr(src,
                                                                 extent);
@@ -2803,6 +3141,299 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
         return ret;
 }
 
+static int extent_cmp(void *priv, struct list_head *a, struct list_head *b)
+{
+        struct extent_map *em1, *em2;
+
+        em1 = list_entry(a, struct extent_map, list);
+        em2 = list_entry(b, struct extent_map, list);
+
+        if (em1->start < em2->start)
+                return -1;
+        else if (em1->start > em2->start)
+                return 1;
+        return 0;
+}
+
+static int drop_adjacent_extents(struct btrfs_trans_handle *trans,
+                                 struct btrfs_root *root, struct inode *inode,
+                                 struct extent_map *em,
+                                 struct btrfs_path *path)
+{
+        struct btrfs_file_extent_item *fi;
+        struct extent_buffer *leaf;
+        struct btrfs_key key, new_key;
+        struct btrfs_map_token token;
+        u64 extent_end;
+        u64 extent_offset = 0;
+        int extent_type;
+        int del_slot = 0;
+        int del_nr = 0;
+        int ret = 0;
+
+        while (1) {
+                btrfs_init_map_token(&token);
+                leaf = path->nodes[0];
+                path->slots[0]++;
+                if (path->slots[0] >= btrfs_header_nritems(leaf)) {
+                        if (del_nr) {
+                                ret = btrfs_del_items(trans, root, path,
+                                                      del_slot, del_nr);
+                                if (ret)
+                                        return ret;
+                                del_nr = 0;
+                        }
+
+                        ret = btrfs_next_leaf_write(trans, root, path, 1);
+                        if (ret < 0)
+                                return ret;
+                        if (ret > 0)
+                                return 0;
+                        leaf = path->nodes[0];
+                }
+
+                btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
+                if (key.objectid != btrfs_ino(inode) ||
+                    key.type != BTRFS_EXTENT_DATA_KEY ||
+                    key.offset >= em->start + em->len)
+                        break;
+
+                fi = btrfs_item_ptr(leaf, path->slots[0],
+                                    struct btrfs_file_extent_item);
+                extent_type = btrfs_token_file_extent_type(leaf, fi, &token);
+                if (extent_type == BTRFS_FILE_EXTENT_REG ||
+                    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
+                        extent_offset = btrfs_token_file_extent_offset(leaf,
+                                                                fi, &token);
+                        extent_end = key.offset +
+                                btrfs_token_file_extent_num_bytes(leaf, fi,
+                                                                  &token);
+                } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
+                        extent_end = key.offset +
+                                btrfs_file_extent_inline_len(leaf, fi);
+                } else {
+                        BUG();
+                }
+
+                if (extent_end <= em->len + em->start) {
+                        if (!del_nr) {
+                                del_slot = path->slots[0];
+                        }
+                        del_nr++;
+                        continue;
+                }
+
+                /*
+                 * Ok so we'll ignore previous items if we log a new extent,
+                 * which can lead to overlapping extents, so if we have an
+                 * existing extent we want to adjust we _have_ to check the next
+                 * guy to make sure we even need this extent anymore, this keeps
+                 * us from panicing in set_item_key_safe.
+                 */
+                if (path->slots[0] < btrfs_header_nritems(leaf) - 1) {
+                        struct btrfs_key tmp_key;
+
+                        btrfs_item_key_to_cpu(leaf, &tmp_key,
+                                              path->slots[0] + 1);
+                        if (tmp_key.objectid == btrfs_ino(inode) &&
+                            tmp_key.type == BTRFS_EXTENT_DATA_KEY &&
+                            tmp_key.offset <= em->start + em->len) {
+                                if (!del_nr)
+                                        del_slot = path->slots[0];
+                                del_nr++;
+                                continue;
+                        }
+                }
+
+                BUG_ON(extent_type == BTRFS_FILE_EXTENT_INLINE);
+                memcpy(&new_key, &key, sizeof(new_key));
+                new_key.offset = em->start + em->len;
+                btrfs_set_item_key_safe(trans, root, path, &new_key);
+                extent_offset += em->start + em->len - key.offset;
+                btrfs_set_token_file_extent_offset(leaf, fi, extent_offset,
+                                                   &token);
+                btrfs_set_token_file_extent_num_bytes(leaf, fi, extent_end -
+                                                      (em->start + em->len),
+                                                      &token);
+                btrfs_mark_buffer_dirty(leaf);
+        }
+
+        if (del_nr)
+                ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
+
+        return ret;
+}
+
+static int log_one_extent(struct btrfs_trans_handle *trans,
+                          struct inode *inode, struct btrfs_root *root,
+                          struct extent_map *em, struct btrfs_path *path)
+{
+        struct btrfs_root *log = root->log_root;
+        struct btrfs_file_extent_item *fi;
+        struct extent_buffer *leaf;
+        struct list_head ordered_sums;
+        struct btrfs_map_token token;
+        struct btrfs_key key;
+        u64 csum_offset = em->mod_start - em->start;
+        u64 csum_len = em->mod_len;
+        u64 extent_offset = em->start - em->orig_start;
+        u64 block_len;
+        int ret;
+        bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
+
+        INIT_LIST_HEAD(&ordered_sums);
+        btrfs_init_map_token(&token);
+        key.objectid = btrfs_ino(inode);
+        key.type = BTRFS_EXTENT_DATA_KEY;
+        key.offset = em->start;
+        path->really_keep_locks = 1;
+
+        ret = btrfs_insert_empty_item(trans, log, path, &key, sizeof(*fi));
+        if (ret && ret != -EEXIST) {
+                path->really_keep_locks = 0;
+                return ret;
+        }
+        leaf = path->nodes[0];
+        fi = btrfs_item_ptr(leaf, path->slots[0],
+                            struct btrfs_file_extent_item);
+        btrfs_set_token_file_extent_generation(leaf, fi, em->generation,
+                                               &token);
+        if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
+                skip_csum = true;
+                btrfs_set_token_file_extent_type(leaf, fi,
+                                                 BTRFS_FILE_EXTENT_PREALLOC,
+                                                 &token);
+        } else {
+                btrfs_set_token_file_extent_type(leaf, fi,
+                                                 BTRFS_FILE_EXTENT_REG,
+                                                 &token);
+                if (em->block_start == 0)
+                        skip_csum = true;
+        }
+
+        block_len = max(em->block_len, em->orig_block_len);
+        if (em->compress_type != BTRFS_COMPRESS_NONE) {
+                btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
+                                                        em->block_start,
+                                                        &token);
+                btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
+                                                           &token);
+        } else if (em->block_start < EXTENT_MAP_LAST_BYTE) {
+                btrfs_set_token_file_extent_disk_bytenr(leaf, fi,
+                                                        em->block_start -
+                                                        extent_offset, &token);
+                btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, block_len,
+                                                           &token);
+        } else {
+                btrfs_set_token_file_extent_disk_bytenr(leaf, fi, 0, &token);
+                btrfs_set_token_file_extent_disk_num_bytes(leaf, fi, 0,
+                                                           &token);
+        }
+
+        btrfs_set_token_file_extent_offset(leaf, fi,
+                                           em->start - em->orig_start,
+                                           &token);
+        btrfs_set_token_file_extent_num_bytes(leaf, fi, em->len, &token);
+        btrfs_set_token_file_extent_ram_bytes(leaf, fi, em->len, &token);
+        btrfs_set_token_file_extent_compression(leaf, fi, em->compress_type,
+                                                &token);
+        btrfs_set_token_file_extent_encryption(leaf, fi, 0, &token);
+        btrfs_set_token_file_extent_other_encoding(leaf, fi, 0, &token);
+        btrfs_mark_buffer_dirty(leaf);
+
+        /*
+         * Have to check the extent to the right of us to make sure it doesn't
+         * fall in our current range.  We're ok if the previous extent is in our
+         * range since the recovery stuff will run us in key order and thus just
+         * drop the part we overwrote.
+         */
+        ret = drop_adjacent_extents(trans, log, inode, em, path);
+        btrfs_release_path(path);
+        path->really_keep_locks = 0;
+        if (ret) {
+                return ret;
+        }
+
+        if (skip_csum)
+                return 0;
+
+        /* block start is already adjusted for the file extent offset. */
+        ret = btrfs_lookup_csums_range(log->fs_info->csum_root,
+                                       em->block_start + csum_offset,
+                                       em->block_start + csum_offset +
+                                       csum_len - 1, &ordered_sums, 0);
+        if (ret)
+                return ret;
+
+        while (!list_empty(&ordered_sums)) {
+                struct btrfs_ordered_sum *sums = list_entry(ordered_sums.next,
+                                                   struct btrfs_ordered_sum,
+                                                   list);
+                if (!ret)
+                        ret = btrfs_csum_file_blocks(trans, log, sums);
+                list_del(&sums->list);
+                kfree(sums);
+        }
+
+        return ret;
+}
+
+static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
+                                     struct btrfs_root *root,
+                                     struct inode *inode,
+                                     struct btrfs_path *path)
+{
+        struct extent_map *em, *n;
+        struct list_head extents;
+        struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
+        u64 test_gen;
+        int ret = 0;
+
+        INIT_LIST_HEAD(&extents);
+
+        write_lock(&tree->lock);
+        test_gen = root->fs_info->last_trans_committed;
+
+        list_for_each_entry_safe(em, n, &tree->modified_extents, list) {
+                list_del_init(&em->list);
+                if (em->generation <= test_gen)
+                        continue;
+                /* Need a ref to keep it from getting evicted from cache */
+                atomic_inc(&em->refs);
+                set_bit(EXTENT_FLAG_LOGGING, &em->flags);
+                list_add_tail(&em->list, &extents);
+        }
+
+        list_sort(NULL, &extents, extent_cmp);
+
+        while (!list_empty(&extents)) {
+                em = list_entry(extents.next, struct extent_map, list);
+
+                list_del_init(&em->list);
+                clear_bit(EXTENT_FLAG_LOGGING, &em->flags);
+
+                /*
+                 * If we had an error we just need to delete everybody from our
+                 * private list.
+                 */
+                if (ret) {
+                        free_extent_map(em);
+                        continue;
+                }
+
+                write_unlock(&tree->lock);
+
+                ret = log_one_extent(trans, inode, root, em, path);
+                free_extent_map(em);
+                write_lock(&tree->lock);
+        }
+        WARN_ON(!list_empty(&extents));
+        write_unlock(&tree->lock);
+
+        btrfs_release_path(path);
+        return ret;
+}
+
 /* log a single inode in the tree log.
  * At least one parent directory for this inode must exist in the tree
  * or be logged already.
@@ -2832,6 +3463,7 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
         int nritems;
         int ins_start_slot = 0;
         int ins_nr;
+        bool fast_search = false;
         u64 ino = btrfs_ino(inode);
 
         log = root->log_root;
@@ -2851,21 +3483,26 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
 
         max_key.objectid = ino;
 
-        /* today the code can only do partial logging of directories */
-        if (!S_ISDIR(inode->i_mode))
-            inode_only = LOG_INODE_ALL;
 
-        if (inode_only == LOG_INODE_EXISTS || S_ISDIR(inode->i_mode))
+        /* today the code can only do partial logging of directories */
+        if (S_ISDIR(inode->i_mode) ||
+            (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                       &BTRFS_I(inode)->runtime_flags) &&
+             inode_only == LOG_INODE_EXISTS))
                 max_key.type = BTRFS_XATTR_ITEM_KEY;
         else
                 max_key.type = (u8)-1;
         max_key.offset = (u64)-1;
 
-        ret = btrfs_commit_inode_delayed_items(trans, inode);
-        if (ret) {
-                btrfs_free_path(path);
-                btrfs_free_path(dst_path);
-                return ret;
+        /* Only run delayed items if we are a dir or a new file */
+        if (S_ISDIR(inode->i_mode) ||
+            BTRFS_I(inode)->generation > root->fs_info->last_trans_committed) {
+                ret = btrfs_commit_inode_delayed_items(trans, inode);
+                if (ret) {
+                        btrfs_free_path(path);
+                        btrfs_free_path(dst_path);
+                        return ret;
+                }
         }
 
         mutex_lock(&BTRFS_I(inode)->log_mutex);
@@ -2881,7 +3518,30 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                         max_key_type = BTRFS_XATTR_ITEM_KEY;
                 ret = drop_objectid_items(trans, log, path, ino, max_key_type);
         } else {
-                ret = btrfs_truncate_inode_items(trans, log, inode, 0, 0);
+                if (test_and_clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
+                                       &BTRFS_I(inode)->runtime_flags)) {
+                        clear_bit(BTRFS_INODE_COPY_EVERYTHING,
+                                  &BTRFS_I(inode)->runtime_flags);
+                        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)) {
+                        if (inode_only == LOG_INODE_ALL)
+                                fast_search = true;
+                        max_key.type = BTRFS_XATTR_ITEM_KEY;
+                        ret = drop_objectid_items(trans, log, path, ino,
+                                                  max_key.type);
+                } else {
+                        if (inode_only == LOG_INODE_ALL)
+                                fast_search = true;
+                        ret = log_inode_item(trans, log, dst_path, inode);
+                        if (ret) {
+                                err = ret;
+                                goto out_unlock;
+                        }
+                        goto log_extents;
+                }
+
         }
         if (ret) {
                 err = ret;
@@ -2912,7 +3572,7 @@ again:
                         goto next_slot;
                 }
 
-                ret = copy_items(trans, log, dst_path, src, ins_start_slot,
+                ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
                                  ins_nr, inode_only);
                 if (ret) {
                         err = ret;
@@ -2930,7 +3590,7 @@ next_slot:
                         goto again;
                 }
                 if (ins_nr) {
-                        ret = copy_items(trans, log, dst_path, src,
+                        ret = copy_items(trans, inode, dst_path, src,
                                          ins_start_slot,
                                          ins_nr, inode_only);
                         if (ret) {
@@ -2951,8 +3611,7 @@ next_slot:
                         break;
         }
         if (ins_nr) {
-                ret = copy_items(trans, log, dst_path, src,
-                                 ins_start_slot,
+                ret = copy_items(trans, inode, dst_path, src, ins_start_slot,
                                  ins_nr, inode_only);
                 if (ret) {
                         err = ret;
@@ -2960,7 +3619,25 @@ next_slot:
                 }
                 ins_nr = 0;
         }
-        WARN_ON(ins_nr);
+
+log_extents:
+        if (fast_search) {
+                btrfs_release_path(dst_path);
+                ret = btrfs_log_changed_extents(trans, root, inode, dst_path);
+                if (ret) {
+                        err = ret;
+                        goto out_unlock;
+                }
+        } else {
+                struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
+                struct extent_map *em, *n;
+
+                write_lock(&tree->lock);
+                list_for_each_entry_safe(em, n, &tree->modified_extents, list)
+                        list_del_init(&em->list);
+                write_unlock(&tree->lock);
+        }
+
         if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
                 btrfs_release_path(path);
                 btrfs_release_path(dst_path);
@@ -2971,6 +3648,7 @@ next_slot:
                 }
         }
         BTRFS_I(inode)->logged_trans = trans->transid;
+        BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
 out_unlock:
         mutex_unlock(&BTRFS_I(inode)->log_mutex);
 
@@ -3138,7 +3816,7 @@ int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
 end_trans:
         dput(old_parent);
         if (ret < 0) {
-                BUG_ON(ret != -ENOSPC);
+                WARN_ON(ret != -ENOSPC);
                 root->fs_info->last_trans_log_full_commit = trans->transid;
                 ret = 1;
         }
diff --git a/fs/btrfs/ulist.c b/fs/btrfs/ulist.c
index ab942f46b3dd..99be4c138db6 100644
--- a/fs/btrfs/ulist.c
+++ b/fs/btrfs/ulist.c
@@ -143,14 +143,13 @@ EXPORT_SYMBOL(ulist_free);
  * In case of allocation failure -ENOMEM is returned and the ulist stays
  * unaltered.
  */
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-              gfp_t gfp_mask)
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask)
 {
         return ulist_add_merge(ulist, val, aux, NULL, gfp_mask);
 }
 
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                    unsigned long *old_aux, gfp_t gfp_mask)
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                    u64 *old_aux, gfp_t gfp_mask)
 {
         int i;
 
diff --git a/fs/btrfs/ulist.h b/fs/btrfs/ulist.h
index 21bdc8ec8130..21a1963439c3 100644
--- a/fs/btrfs/ulist.h
+++ b/fs/btrfs/ulist.h
@@ -33,7 +33,7 @@ struct ulist_iterator {
  */
 struct ulist_node {
         u64 val;                /* value to store */
-        unsigned long aux;      /* auxiliary value saved along with the val */
+        u64 aux;                /* auxiliary value saved along with the val */
 };
 
 struct ulist {
@@ -65,10 +65,9 @@ void ulist_fini(struct ulist *ulist);
 void ulist_reinit(struct ulist *ulist);
 struct ulist *ulist_alloc(gfp_t gfp_mask);
 void ulist_free(struct ulist *ulist);
-int ulist_add(struct ulist *ulist, u64 val, unsigned long aux,
-              gfp_t gfp_mask);
-int ulist_add_merge(struct ulist *ulist, u64 val, unsigned long aux,
-                    unsigned long *old_aux, gfp_t gfp_mask);
+int ulist_add(struct ulist *ulist, u64 val, u64 aux, gfp_t gfp_mask);
+int ulist_add_merge(struct ulist *ulist, u64 val, u64 aux,
+                    u64 *old_aux, gfp_t gfp_mask);
 struct ulist_node *ulist_next(struct ulist *ulist,
                               struct ulist_iterator *uiter);
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 88b969aeeb71..5cce6aa74012 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -25,7 +25,6 @@
 #include <linux/capability.h>
 #include <linux/ratelimit.h>
 #include <linux/kthread.h>
-#include <asm/div64.h>
 #include "compat.h"
 #include "ctree.h"
 #include "extent_map.h"
@@ -36,6 +35,8 @@
 #include "async-thread.h"
 #include "check-integrity.h"
 #include "rcu-string.h"
+#include "math.h"
+#include "dev-replace.h"
 
 static int init_first_rw_device(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root,
@@ -71,6 +72,19 @@ static void free_fs_devices(struct btrfs_fs_devices *fs_devices)
         kfree(fs_devices);
 }
 
+static void btrfs_kobject_uevent(struct block_device *bdev,
+                                 enum kobject_action action)
+{
+        int ret;
+
+        ret = kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, action);
+        if (ret)
+                pr_warn("Sending event '%d' to kobject: '%s' (%p): failed\n",
+                        action,
+                        kobject_name(&disk_to_dev(bdev->bd_disk)->kobj),
+                        &disk_to_dev(bdev->bd_disk)->kobj);
+}
+
 void btrfs_cleanup_fs_uuids(void)
 {
         struct btrfs_fs_devices *fs_devices;
@@ -108,6 +122,44 @@ static noinline struct btrfs_fs_devices *find_fsid(u8 *fsid)
         return NULL;
 }
 
+static int
+btrfs_get_bdev_and_sb(const char *device_path, fmode_t flags, void *holder,
+                      int flush, struct block_device **bdev,
+                      struct buffer_head **bh)
+{
+        int ret;
+
+        *bdev = blkdev_get_by_path(device_path, flags, holder);
+
+        if (IS_ERR(*bdev)) {
+                ret = PTR_ERR(*bdev);
+                printk(KERN_INFO "btrfs: open %s failed\n", device_path);
+                goto error;
+        }
+
+        if (flush)
+                filemap_write_and_wait((*bdev)->bd_inode->i_mapping);
+        ret = set_blocksize(*bdev, 4096);
+        if (ret) {
+                blkdev_put(*bdev, flags);
+                goto error;
+        }
+        invalidate_bdev(*bdev);
+        *bh = btrfs_read_dev_super(*bdev);
+        if (!*bh) {
+                ret = -EINVAL;
+                blkdev_put(*bdev, flags);
+                goto error;
+        }
+
+        return 0;
+
+error:
+        *bdev = NULL;
+        *bh = NULL;
+        return ret;
+}
+
 static void requeue_list(struct btrfs_pending_bios *pending_bios,
                         struct bio *head, struct bio *tail)
 {
@@ -467,7 +519,8 @@ error:
         return ERR_PTR(-ENOMEM);
 }
 
-void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices)
+void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
+                               struct btrfs_fs_devices *fs_devices, int step)
 {
         struct btrfs_device *device, *next;
 
@@ -480,8 +533,9 @@ again:
         /* This is the initialized path, it is safe to release the devices. */
         list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
                 if (device->in_fs_metadata) {
-                        if (!latest_transid ||
-                            device->generation > latest_transid) {
+                        if (!device->is_tgtdev_for_dev_replace &&
+                            (!latest_transid ||
+                             device->generation > latest_transid)) {
                                 latest_devid = device->devid;
                                 latest_transid = device->generation;
                                 latest_bdev = device->bdev;
@@ -489,6 +543,21 @@ again:
                         continue;
                 }
 
+                if (device->devid == BTRFS_DEV_REPLACE_DEVID) {
+                        /*
+                         * In the first step, keep the device which has
+                         * the correct fsid and the devid that is used
+                         * for the dev_replace procedure.
+                         * In the second step, the dev_replace state is
+                         * read from the device tree and it is known
+                         * whether the procedure is really active or
+                         * not, which means whether this device is
+                         * used or whether it should be removed.
+                         */
+                        if (step == 0 || device->is_tgtdev_for_dev_replace) {
+                                continue;
+                        }
+                }
                 if (device->bdev) {
                         blkdev_put(device->bdev, device->mode);
                         device->bdev = NULL;
@@ -497,7 +566,8 @@ again:
                 if (device->writeable) {
                         list_del_init(&device->dev_alloc_list);
                         device->writeable = 0;
-                        fs_devices->rw_devices--;
+                        if (!device->is_tgtdev_for_dev_replace)
+                                fs_devices->rw_devices--;
                 }
                 list_del_init(&device->dev_list);
                 fs_devices->num_devices--;
@@ -555,7 +625,7 @@ static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices)
                 if (device->bdev)
                         fs_devices->open_devices--;
 
-                if (device->writeable) {
+                if (device->writeable && !device->is_tgtdev_for_dev_replace) {
                         list_del_init(&device->dev_alloc_list);
                         fs_devices->rw_devices--;
                 }
@@ -637,18 +707,10 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
                 if (!device->name)
                         continue;
 
-                bdev = blkdev_get_by_path(device->name->str, flags, holder);
-                if (IS_ERR(bdev)) {
-                        printk(KERN_INFO "open %s failed\n", device->name->str);
-                        goto error;
-                }
-                filemap_write_and_wait(bdev->bd_inode->i_mapping);
-                invalidate_bdev(bdev);
-                set_blocksize(bdev, 4096);
-
-                bh = btrfs_read_dev_super(bdev);
-                if (!bh)
-                        goto error_close;
+                ret = btrfs_get_bdev_and_sb(device->name->str, flags, holder, 1,
+                                            &bdev, &bh);
+                if (ret)
+                        continue;
 
                 disk_super = (struct btrfs_super_block *)bh->b_data;
                 devid = btrfs_stack_device_id(&disk_super->dev_item);
@@ -687,7 +749,7 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
                         fs_devices->rotating = 1;
 
                 fs_devices->open_devices++;
-                if (device->writeable) {
+                if (device->writeable && !device->is_tgtdev_for_dev_replace) {
                         fs_devices->rw_devices++;
                         list_add(&device->dev_alloc_list,
                                  &fs_devices->alloc_list);
@@ -697,9 +759,7 @@ static int __btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
 
 error_brelse:
                 brelse(bh);
-error_close:
                 blkdev_put(bdev, flags);
-error:
                 continue;
         }
         if (fs_devices->open_devices == 0) {
@@ -744,40 +804,30 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
         u64 total_devices;
 
         flags |= FMODE_EXCL;
-        bdev = blkdev_get_by_path(path, flags, holder);
-
-        if (IS_ERR(bdev)) {
-                ret = PTR_ERR(bdev);
-                goto error;
-        }
-
         mutex_lock(&uuid_mutex);
-        ret = set_blocksize(bdev, 4096);
+        ret = btrfs_get_bdev_and_sb(path, flags, holder, 0, &bdev, &bh);
         if (ret)
-                goto error_close;
-        bh = btrfs_read_dev_super(bdev);
-        if (!bh) {
-                ret = -EINVAL;
-                goto error_close;
-        }
+                goto error;
         disk_super = (struct btrfs_super_block *)bh->b_data;
         devid = btrfs_stack_device_id(&disk_super->dev_item);
         transid = btrfs_super_generation(disk_super);
         total_devices = btrfs_super_num_devices(disk_super);
-        if (disk_super->label[0])
+        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);
-        else
+        } else {
                 printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
+        }
         printk(KERN_CONT "devid %llu transid %llu %s\n",
                (unsigned long long)devid, (unsigned long long)transid, path);
         ret = device_list_add(path, disk_super, devid, fs_devices_ret);
         if (!ret && fs_devices_ret)
                 (*fs_devices_ret)->total_devices = total_devices;
         brelse(bh);
-error_close:
-        mutex_unlock(&uuid_mutex);
         blkdev_put(bdev, flags);
 error:
+        mutex_unlock(&uuid_mutex);
         return ret;
 }
 
@@ -796,7 +846,7 @@ int btrfs_account_dev_extents_size(struct btrfs_device *device, u64 start,
 
         *length = 0;
 
-        if (start >= device->total_bytes)
+        if (start >= device->total_bytes || device->is_tgtdev_for_dev_replace)
                 return 0;
 
         path = btrfs_alloc_path();
@@ -913,7 +963,7 @@ int find_free_dev_extent(struct btrfs_device *device, u64 num_bytes,
         max_hole_size = 0;
         hole_size = 0;
 
-        if (search_start >= search_end) {
+        if (search_start >= search_end || device->is_tgtdev_for_dev_replace) {
                 ret = -ENOSPC;
                 goto error;
         }
@@ -1096,6 +1146,7 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
         struct btrfs_key key;
 
         WARN_ON(!device->in_fs_metadata);
+        WARN_ON(device->is_tgtdev_for_dev_replace);
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
@@ -1330,16 +1381,22 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                 root->fs_info->avail_system_alloc_bits |
                 root->fs_info->avail_metadata_alloc_bits;
 
-        if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) &&
-            root->fs_info->fs_devices->num_devices <= 4) {
+        num_devices = root->fs_info->fs_devices->num_devices;
+        btrfs_dev_replace_lock(&root->fs_info->dev_replace);
+        if (btrfs_dev_replace_is_ongoing(&root->fs_info->dev_replace)) {
+                WARN_ON(num_devices < 1);
+                num_devices--;
+        }
+        btrfs_dev_replace_unlock(&root->fs_info->dev_replace);
+
+        if ((all_avail & BTRFS_BLOCK_GROUP_RAID10) && num_devices <= 4) {
                 printk(KERN_ERR "btrfs: unable to go below four devices "
                        "on raid10\n");
                 ret = -EINVAL;
                 goto out;
         }
 
-        if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) &&
-            root->fs_info->fs_devices->num_devices <= 2) {
+        if ((all_avail & BTRFS_BLOCK_GROUP_RAID1) && num_devices <= 2) {
                 printk(KERN_ERR "btrfs: unable to go below two "
                        "devices on raid1\n");
                 ret = -EINVAL;
@@ -1357,7 +1414,9 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                  * is held.
                  */
                 list_for_each_entry(tmp, devices, dev_list) {
-                        if (tmp->in_fs_metadata && !tmp->bdev) {
+                        if (tmp->in_fs_metadata &&
+                            !tmp->is_tgtdev_for_dev_replace &&
+                            !tmp->bdev) {
                                 device = tmp;
                                 break;
                         }
@@ -1371,24 +1430,16 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                         goto out;
                 }
         } else {
-                bdev = blkdev_get_by_path(device_path, FMODE_READ | FMODE_EXCL,
-                                          root->fs_info->bdev_holder);
-                if (IS_ERR(bdev)) {
-                        ret = PTR_ERR(bdev);
+                ret = btrfs_get_bdev_and_sb(device_path,
+                                            FMODE_READ | FMODE_EXCL,
+                                            root->fs_info->bdev_holder, 0,
+                                            &bdev, &bh);
+                if (ret)
                         goto out;
-                }
-
-                set_blocksize(bdev, 4096);
-                invalidate_bdev(bdev);
-                bh = btrfs_read_dev_super(bdev);
-                if (!bh) {
-                        ret = -EINVAL;
-                        goto error_close;
-                }
                 disk_super = (struct btrfs_super_block *)bh->b_data;
                 devid = btrfs_stack_device_id(&disk_super->dev_item);
                 dev_uuid = disk_super->dev_item.uuid;
-                device = btrfs_find_device(root, devid, dev_uuid,
+                device = btrfs_find_device(root->fs_info, devid, dev_uuid,
                                            disk_super->fsid);
                 if (!device) {
                         ret = -ENOENT;
@@ -1396,6 +1447,12 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                 }
         }
 
+        if (device->is_tgtdev_for_dev_replace) {
+                pr_err("btrfs: unable to remove the dev_replace target dev\n");
+                ret = -EINVAL;
+                goto error_brelse;
+        }
+
         if (device->writeable && root->fs_info->fs_devices->rw_devices == 1) {
                 printk(KERN_ERR "btrfs: unable to remove the only writeable "
                        "device\n");
@@ -1415,6 +1472,11 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
         if (ret)
                 goto error_undo;
 
+        /*
+         * TODO: the superblock still includes this device in its num_devices
+         * counter although write_all_supers() is not locked out. This
+         * could give a filesystem state which requires a degraded mount.
+         */
         ret = btrfs_rm_dev_item(root->fs_info->chunk_root, device);
         if (ret)
                 goto error_undo;
@@ -1425,7 +1487,7 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
         spin_unlock(&root->fs_info->free_chunk_lock);
 
         device->in_fs_metadata = 0;
-        btrfs_scrub_cancel_dev(root, device);
+        btrfs_scrub_cancel_dev(root->fs_info, device);
 
         /*
          * the device list mutex makes sure that we don't change
@@ -1475,11 +1537,14 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
                 free_fs_devices(cur_devices);
         }
 
+        root->fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
+
         /*
          * at this point, the device is zero sized.  We want to
          * remove it from the devices list and zero out the old super
          */
-        if (clear_super) {
+        if (clear_super && disk_super) {
                 /* make sure this device isn't detected as part of
                  * the FS anymore
                  */
@@ -1490,9 +1555,11 @@ int btrfs_rm_device(struct btrfs_root *root, char *device_path)
 
         ret = 0;
 
+        /* Notify udev that device has changed */
+        btrfs_kobject_uevent(bdev, KOBJ_CHANGE);
+
 error_brelse:
         brelse(bh);
-error_close:
         if (bdev)
                 blkdev_put(bdev, FMODE_READ | FMODE_EXCL);
 out:
@@ -1509,6 +1576,112 @@ error_undo:
         goto error_brelse;
 }
 
+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--;
+        if (srcdev->missing) {
+                fs_info->fs_devices->missing_devices--;
+                fs_info->fs_devices->rw_devices++;
+        }
+        if (srcdev->can_discard)
+                fs_info->fs_devices->num_can_discard--;
+        if (srcdev->bdev)
+                fs_info->fs_devices->open_devices--;
+
+        call_rcu(&srcdev->rcu, free_device);
+}
+
+void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
+                                      struct btrfs_device *tgtdev)
+{
+        struct btrfs_device *next_device;
+
+        WARN_ON(!tgtdev);
+        mutex_lock(&fs_info->fs_devices->device_list_mutex);
+        if (tgtdev->bdev) {
+                btrfs_scratch_superblock(tgtdev);
+                fs_info->fs_devices->open_devices--;
+        }
+        fs_info->fs_devices->num_devices--;
+        if (tgtdev->can_discard)
+                fs_info->fs_devices->num_can_discard++;
+
+        next_device = list_entry(fs_info->fs_devices->devices.next,
+                                 struct btrfs_device, dev_list);
+        if (tgtdev->bdev == fs_info->sb->s_bdev)
+                fs_info->sb->s_bdev = next_device->bdev;
+        if (tgtdev->bdev == fs_info->fs_devices->latest_bdev)
+                fs_info->fs_devices->latest_bdev = next_device->bdev;
+        list_del_rcu(&tgtdev->dev_list);
+
+        call_rcu(&tgtdev->rcu, free_device);
+
+        mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+}
+
+int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
+                              struct btrfs_device **device)
+{
+        int ret = 0;
+        struct btrfs_super_block *disk_super;
+        u64 devid;
+        u8 *dev_uuid;
+        struct block_device *bdev;
+        struct buffer_head *bh;
+
+        *device = NULL;
+        ret = btrfs_get_bdev_and_sb(device_path, FMODE_READ,
+                                    root->fs_info->bdev_holder, 0, &bdev, &bh);
+        if (ret)
+                return ret;
+        disk_super = (struct btrfs_super_block *)bh->b_data;
+        devid = btrfs_stack_device_id(&disk_super->dev_item);
+        dev_uuid = disk_super->dev_item.uuid;
+        *device = btrfs_find_device(root->fs_info, devid, dev_uuid,
+                                    disk_super->fsid);
+        brelse(bh);
+        if (!*device)
+                ret = -ENOENT;
+        blkdev_put(bdev, FMODE_READ);
+        return ret;
+}
+
+int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
+                                         char *device_path,
+                                         struct btrfs_device **device)
+{
+        *device = NULL;
+        if (strcmp(device_path, "missing") == 0) {
+                struct list_head *devices;
+                struct btrfs_device *tmp;
+
+                devices = &root->fs_info->fs_devices->devices;
+                /*
+                 * It is safe to read the devices since the volume_mutex
+                 * is held by the caller.
+                 */
+                list_for_each_entry(tmp, devices, dev_list) {
+                        if (tmp->in_fs_metadata && !tmp->bdev) {
+                                *device = tmp;
+                                break;
+                        }
+                }
+
+                if (!*device) {
+                        pr_err("btrfs: no missing device found\n");
+                        return -ENOENT;
+                }
+
+                return 0;
+        } else {
+                return btrfs_find_device_by_path(root, device_path, device);
+        }
+}
+
 /*
  * does all the dirty work required for changing file system's UUID.
  */
@@ -1627,7 +1800,8 @@ next_slot:
                 read_extent_buffer(leaf, fs_uuid,
                                    (unsigned long)btrfs_device_fsid(dev_item),
                                    BTRFS_UUID_SIZE);
-                device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
+                device = btrfs_find_device(root->fs_info, devid, dev_uuid,
+                                           fs_uuid);
                 BUG_ON(!device); /* Logic error */
 
                 if (device->fs_devices->seeding) {
@@ -1675,16 +1849,17 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
         filemap_write_and_wait(bdev->bd_inode->i_mapping);
 
         devices = &root->fs_info->fs_devices->devices;
-        /*
-         * we have the volume lock, so we don't need the extra
-         * device list mutex while reading the list here.
-         */
+
+        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
         list_for_each_entry(device, devices, dev_list) {
                 if (device->bdev == bdev) {
                         ret = -EEXIST;
+                        mutex_unlock(
+                                &root->fs_info->fs_devices->device_list_mutex);
                         goto error;
                 }
         }
+        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
 
         device = kzalloc(sizeof(*device), GFP_NOFS);
         if (!device) {
@@ -1734,6 +1909,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
         device->dev_root = root->fs_info->dev_root;
         device->bdev = bdev;
         device->in_fs_metadata = 1;
+        device->is_tgtdev_for_dev_replace = 0;
         device->mode = FMODE_EXCL;
         set_blocksize(device->bdev, 4096);
 
@@ -1775,15 +1951,21 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
 
         if (seeding_dev) {
                 ret = init_first_rw_device(trans, root, device);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
                 ret = btrfs_finish_sprout(trans, root);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
         } else {
                 ret = btrfs_add_device(trans, root, device);
-                if (ret)
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
                         goto error_trans;
+                }
         }
 
         /*
@@ -1793,6 +1975,8 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
         btrfs_clear_space_info_full(root->fs_info);
 
         unlock_chunks(root);
+        root->fs_info->num_tolerated_disk_barrier_failures =
+                btrfs_calc_num_tolerated_disk_barrier_failures(root->fs_info);
         ret = btrfs_commit_transaction(trans, root);
 
         if (seeding_dev) {
@@ -1808,13 +1992,19 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
                                     "Failed to relocate sys chunks after "
                                     "device initialization. This can be fixed "
                                     "using the \"btrfs balance\" command.");
+                trans = btrfs_attach_transaction(root);
+                if (IS_ERR(trans)) {
+                        if (PTR_ERR(trans) == -ENOENT)
+                                return 0;
+                        return PTR_ERR(trans);
+                }
+                ret = btrfs_commit_transaction(trans, root);
         }
 
         return ret;
 
 error_trans:
         unlock_chunks(root);
-        btrfs_abort_transaction(trans, root, ret);
         btrfs_end_transaction(trans, root);
         rcu_string_free(device->name);
         kfree(device);
@@ -1827,6 +2017,98 @@ error:
         return ret;
 }
 
+int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
+                                  struct btrfs_device **device_out)
+{
+        struct request_queue *q;
+        struct btrfs_device *device;
+        struct block_device *bdev;
+        struct btrfs_fs_info *fs_info = root->fs_info;
+        struct list_head *devices;
+        struct rcu_string *name;
+        int ret = 0;
+
+        *device_out = NULL;
+        if (fs_info->fs_devices->seeding)
+                return -EINVAL;
+
+        bdev = blkdev_get_by_path(device_path, FMODE_WRITE | FMODE_EXCL,
+                                  fs_info->bdev_holder);
+        if (IS_ERR(bdev))
+                return PTR_ERR(bdev);
+
+        filemap_write_and_wait(bdev->bd_inode->i_mapping);
+
+        devices = &fs_info->fs_devices->devices;
+        list_for_each_entry(device, devices, dev_list) {
+                if (device->bdev == bdev) {
+                        ret = -EEXIST;
+                        goto error;
+                }
+        }
+
+        device = kzalloc(sizeof(*device), GFP_NOFS);
+        if (!device) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        name = rcu_string_strdup(device_path, GFP_NOFS);
+        if (!name) {
+                kfree(device);
+                ret = -ENOMEM;
+                goto error;
+        }
+        rcu_assign_pointer(device->name, name);
+
+        q = bdev_get_queue(bdev);
+        if (blk_queue_discard(q))
+                device->can_discard = 1;
+        mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
+        device->writeable = 1;
+        device->work.func = pending_bios_fn;
+        generate_random_uuid(device->uuid);
+        device->devid = BTRFS_DEV_REPLACE_DEVID;
+        spin_lock_init(&device->io_lock);
+        device->generation = 0;
+        device->io_width = root->sectorsize;
+        device->io_align = root->sectorsize;
+        device->sector_size = root->sectorsize;
+        device->total_bytes = i_size_read(bdev->bd_inode);
+        device->disk_total_bytes = device->total_bytes;
+        device->dev_root = fs_info->dev_root;
+        device->bdev = bdev;
+        device->in_fs_metadata = 1;
+        device->is_tgtdev_for_dev_replace = 1;
+        device->mode = FMODE_EXCL;
+        set_blocksize(device->bdev, 4096);
+        device->fs_devices = fs_info->fs_devices;
+        list_add(&device->dev_list, &fs_info->fs_devices->devices);
+        fs_info->fs_devices->num_devices++;
+        fs_info->fs_devices->open_devices++;
+        if (device->can_discard)
+                fs_info->fs_devices->num_can_discard++;
+        mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
+
+        *device_out = device;
+        return ret;
+
+error:
+        blkdev_put(bdev, FMODE_EXCL);
+        return ret;
+}
+
+void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
+                                              struct btrfs_device *tgtdev)
+{
+        WARN_ON(fs_info->fs_devices->rw_devices == 0);
+        tgtdev->io_width = fs_info->dev_root->sectorsize;
+        tgtdev->io_align = fs_info->dev_root->sectorsize;
+        tgtdev->sector_size = fs_info->dev_root->sectorsize;
+        tgtdev->dev_root = fs_info->dev_root;
+        tgtdev->in_fs_metadata = 1;
+}
+
 static noinline int btrfs_update_device(struct btrfs_trans_handle *trans,
                                         struct btrfs_device *device)
 {
@@ -1883,7 +2165,8 @@ static int __btrfs_grow_device(struct btrfs_trans_handle *trans,
 
         if (!device->writeable)
                 return -EACCES;
-        if (new_size <= device->total_bytes)
+        if (new_size <= device->total_bytes ||
+            device->is_tgtdev_for_dev_replace)
                 return -EINVAL;
 
         btrfs_set_super_total_bytes(super_copy, old_total + diff);
@@ -2321,18 +2604,6 @@ static int chunk_profiles_filter(u64 chunk_type,
         return 1;
 }
 
-static u64 div_factor_fine(u64 num, int factor)
-{
-        if (factor <= 0)
-                return 0;
-        if (factor >= 100)
-                return num;
-
-        num *= factor;
-        do_div(num, 100);
-        return num;
-}
-
 static int chunk_usage_filter(struct btrfs_fs_info *fs_info, u64 chunk_offset,
                               struct btrfs_balance_args *bargs)
 {
@@ -2497,15 +2768,6 @@ static int should_balance_chunk(struct btrfs_root *root,
         return 1;
 }
 
-static u64 div_factor(u64 num, int factor)
-{
-        if (factor == 10)
-                return num;
-        num *= factor;
-        do_div(num, 10);
-        return num;
-}
-
 static int __btrfs_balance(struct btrfs_fs_info *fs_info)
 {
         struct btrfs_balance_control *bctl = fs_info->balance_ctl;
@@ -2533,7 +2795,8 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
                 size_to_free = div_factor(old_size, 1);
                 size_to_free = min(size_to_free, (u64)1 * 1024 * 1024);
                 if (!device->writeable ||
-                    device->total_bytes - device->bytes_used > size_to_free)
+                    device->total_bytes - device->bytes_used > size_to_free ||
+                    device->is_tgtdev_for_dev_replace)
                         continue;
 
                 ret = btrfs_shrink_device(device, old_size - size_to_free);
@@ -2711,6 +2974,7 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
         u64 allowed;
         int mixed = 0;
         int ret;
+        u64 num_devices;
 
         if (btrfs_fs_closing(fs_info) ||
             atomic_read(&fs_info->balance_pause_req) ||
@@ -2739,10 +3003,17 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 }
         }
 
+        num_devices = fs_info->fs_devices->num_devices;
+        btrfs_dev_replace_lock(&fs_info->dev_replace);
+        if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace)) {
+                BUG_ON(num_devices < 1);
+                num_devices--;
+        }
+        btrfs_dev_replace_unlock(&fs_info->dev_replace);
         allowed = BTRFS_AVAIL_ALLOC_BIT_SINGLE;
-        if (fs_info->fs_devices->num_devices == 1)
+        if (num_devices == 1)
                 allowed |= BTRFS_BLOCK_GROUP_DUP;
-        else if (fs_info->fs_devices->num_devices < 4)
+        else if (num_devices < 4)
                 allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1);
         else
                 allowed |= (BTRFS_BLOCK_GROUP_RAID0 | BTRFS_BLOCK_GROUP_RAID1 |
@@ -2804,6 +3075,26 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 }
         }
 
+        if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
+                int num_tolerated_disk_barrier_failures;
+                u64 target = bctl->sys.target;
+
+                num_tolerated_disk_barrier_failures =
+                        btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
+                if (num_tolerated_disk_barrier_failures > 0 &&
+                    (target &
+                     (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID0 |
+                      BTRFS_AVAIL_ALLOC_BIT_SINGLE)))
+                        num_tolerated_disk_barrier_failures = 0;
+                else if (num_tolerated_disk_barrier_failures > 1 &&
+                         (target &
+                          (BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10)))
+                        num_tolerated_disk_barrier_failures = 1;
+
+                fs_info->num_tolerated_disk_barrier_failures =
+                        num_tolerated_disk_barrier_failures;
+        }
+
         ret = insert_balance_item(fs_info->tree_root, bctl);
         if (ret && ret != -EEXIST)
                 goto out;
@@ -2836,6 +3127,11 @@ int btrfs_balance(struct btrfs_balance_control *bctl,
                 __cancel_balance(fs_info);
         }
 
+        if (bctl->sys.flags & BTRFS_BALANCE_ARGS_CONVERT) {
+                fs_info->num_tolerated_disk_barrier_failures =
+                        btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
+        }
+
         wake_up(&fs_info->balance_wait_q);
 
         return ret;
@@ -2860,6 +3156,7 @@ static int balance_kthread(void *data)
                 ret = btrfs_balance(fs_info->balance_ctl, NULL);
         }
 
+        atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
         mutex_unlock(&fs_info->balance_mutex);
         mutex_unlock(&fs_info->volume_mutex);
 
@@ -2882,6 +3179,7 @@ int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
                 return 0;
         }
 
+        WARN_ON(atomic_xchg(&fs_info->mutually_exclusive_operation_running, 1));
         tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
         if (IS_ERR(tsk))
                 return PTR_ERR(tsk);
@@ -3038,7 +3336,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
         u64 old_size = device->total_bytes;
         u64 diff = device->total_bytes - new_size;
 
-        if (new_size >= device->total_bytes)
+        if (device->is_tgtdev_for_dev_replace)
                 return -EINVAL;
 
         path = btrfs_alloc_path();
@@ -3193,6 +3491,14 @@ static int btrfs_cmp_device_info(const void *a, const void *b)
         return 0;
 }
 
+struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES] = {
+        { 2, 1, 0, 4, 2, 2 /* raid10 */ },
+        { 1, 1, 2, 2, 2, 2 /* raid1 */ },
+        { 1, 2, 1, 1, 1, 2 /* dup */ },
+        { 1, 1, 0, 2, 1, 1 /* raid0 */ },
+        { 1, 1, 0, 1, 1, 1 /* single */ },
+};
+
 static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                                struct btrfs_root *extent_root,
                                struct map_lookup **map_ret,
@@ -3222,43 +3528,21 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
         int ndevs;
         int i;
         int j;
+        int index;
 
         BUG_ON(!alloc_profile_is_valid(type, 0));
 
         if (list_empty(&fs_devices->alloc_list))
                 return -ENOSPC;
 
-        sub_stripes = 1;
-        dev_stripes = 1;
-        devs_increment = 1;
-        ncopies = 1;
-        devs_max = 0;   /* 0 == as many as possible */
-        devs_min = 1;
+        index = __get_raid_index(type);
 
-        /*
-         * define the properties of each RAID type.
-         * FIXME: move this to a global table and use it in all RAID
-         * calculation code
-         */
-        if (type & (BTRFS_BLOCK_GROUP_DUP)) {
-                dev_stripes = 2;
-                ncopies = 2;
-                devs_max = 1;
-        } else if (type & (BTRFS_BLOCK_GROUP_RAID0)) {
-                devs_min = 2;
-        } else if (type & (BTRFS_BLOCK_GROUP_RAID1)) {
-                devs_increment = 2;
-                ncopies = 2;
-                devs_max = 2;
-                devs_min = 2;
-        } else if (type & (BTRFS_BLOCK_GROUP_RAID10)) {
-                sub_stripes = 2;
-                devs_increment = 2;
-                ncopies = 2;
-                devs_min = 4;
-        } else {
-                devs_max = 1;
-        }
+        sub_stripes = btrfs_raid_array[index].sub_stripes;
+        dev_stripes = btrfs_raid_array[index].dev_stripes;
+        devs_max = btrfs_raid_array[index].devs_max;
+        devs_min = btrfs_raid_array[index].devs_min;
+        devs_increment = btrfs_raid_array[index].devs_increment;
+        ncopies = btrfs_raid_array[index].ncopies;
 
         if (type & BTRFS_BLOCK_GROUP_DATA) {
                 max_stripe_size = 1024 * 1024 * 1024;
@@ -3305,13 +3589,13 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                 cur = cur->next;
 
                 if (!device->writeable) {
-                        printk(KERN_ERR
+                        WARN(1, KERN_ERR
                                "btrfs: read-only device in alloc_list\n");
-                        WARN_ON(1);
                         continue;
                 }
 
-                if (!device->in_fs_metadata)
+                if (!device->in_fs_metadata ||
+                    device->is_tgtdev_for_dev_replace)
                         continue;
 
                 if (device->total_bytes > device->bytes_used)
@@ -3340,6 +3624,7 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
                 devices_info[ndevs].total_avail = total_avail;
                 devices_info[ndevs].dev = device;
                 ++ndevs;
+                WARN_ON(ndevs > fs_devices->rw_devices);
         }
 
         /*
@@ -3608,12 +3893,16 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
         ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map,
                                   &sys_chunk_size, &sys_stripe_size,
                                   sys_chunk_offset, alloc_profile);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         ret = btrfs_add_device(trans, fs_info->chunk_root, device);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         /*
          * Modifying chunk tree needs allocating new blocks from both
@@ -3623,19 +3912,19 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans,
          */
         ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset,
                                    chunk_size, stripe_size);
-        if (ret)
-                goto abort;
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto out;
+        }
 
         ret = __finish_chunk_alloc(trans, extent_root, sys_map,
                                    sys_chunk_offset, sys_chunk_size,
                                    sys_stripe_size);
         if (ret)
-                goto abort;
+                btrfs_abort_transaction(trans, root, ret);
 
-        return 0;
+out:
 
-abort:
-        btrfs_abort_transaction(trans, root, ret);
         return ret;
 }
 
@@ -3694,8 +3983,9 @@ void btrfs_mapping_tree_free(struct btrfs_mapping_tree *tree)
         }
 }
 
-int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len)
+int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len)
 {
+        struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
         struct extent_map *em;
         struct map_lookup *map;
         struct extent_map_tree *em_tree = &map_tree->map_tree;
@@ -3715,32 +4005,60 @@ int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len)
         else
                 ret = 1;
         free_extent_map(em);
+
+        btrfs_dev_replace_lock(&fs_info->dev_replace);
+        if (btrfs_dev_replace_is_ongoing(&fs_info->dev_replace))
+                ret++;
+        btrfs_dev_replace_unlock(&fs_info->dev_replace);
+
         return ret;
 }
 
-static int find_live_mirror(struct map_lookup *map, int first, int num,
-                            int optimal)
+static int find_live_mirror(struct btrfs_fs_info *fs_info,
+                            struct map_lookup *map, int first, int num,
+                            int optimal, int dev_replace_is_ongoing)
 {
         int i;
-        if (map->stripes[optimal].dev->bdev)
-                return optimal;
-        for (i = first; i < first + num; i++) {
-                if (map->stripes[i].dev->bdev)
-                        return i;
+        int tolerance;
+        struct btrfs_device *srcdev;
+
+        if (dev_replace_is_ongoing &&
+            fs_info->dev_replace.cont_reading_from_srcdev_mode ==
+             BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID)
+                srcdev = fs_info->dev_replace.srcdev;
+        else
+                srcdev = NULL;
+
+        /*
+         * try to avoid the drive that is the source drive for a
+         * dev-replace procedure, only choose it if no other non-missing
+         * mirror is available
+         */
+        for (tolerance = 0; tolerance < 2; tolerance++) {
+                if (map->stripes[optimal].dev->bdev &&
+                    (tolerance || map->stripes[optimal].dev != srcdev))
+                        return optimal;
+                for (i = first; i < first + num; i++) {
+                        if (map->stripes[i].dev->bdev &&
+                            (tolerance || map->stripes[i].dev != srcdev))
+                                return i;
+                }
         }
+
         /* we couldn't find one that doesn't fail.  Just return something
          * and the io error handling code will clean up eventually
          */
         return optimal;
 }
 
-static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+static int __btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                              u64 logical, u64 *length,
                              struct btrfs_bio **bbio_ret,
                              int mirror_num)
 {
         struct extent_map *em;
         struct map_lookup *map;
+        struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
         struct extent_map_tree *em_tree = &map_tree->map_tree;
         u64 offset;
         u64 stripe_offset;
@@ -3754,13 +4072,18 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         int num_stripes;
         int max_errors = 0;
         struct btrfs_bio *bbio = NULL;
+        struct btrfs_dev_replace *dev_replace = &fs_info->dev_replace;
+        int dev_replace_is_ongoing = 0;
+        int num_alloc_stripes;
+        int patch_the_first_stripe_for_dev_replace = 0;
+        u64 physical_to_patch_in_first_stripe = 0;
 
         read_lock(&em_tree->lock);
         em = lookup_extent_mapping(em_tree, logical, *length);
         read_unlock(&em_tree->lock);
 
         if (!em) {
-                printk(KERN_CRIT "unable to find logical %llu len %llu\n",
+                printk(KERN_CRIT "btrfs: unable to find logical %llu len %llu\n",
                        (unsigned long long)logical,
                        (unsigned long long)*length);
                 BUG();
@@ -3770,9 +4093,6 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         map = (struct map_lookup *)em->bdev;
         offset = logical - em->start;
 
-        if (mirror_num > map->num_stripes)
-                mirror_num = 0;
-
         stripe_nr = offset;
         /*
          * stripe_nr counts the total number of stripes we have to stride
@@ -3799,6 +4119,93 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         if (!bbio_ret)
                 goto out;
 
+        btrfs_dev_replace_lock(dev_replace);
+        dev_replace_is_ongoing = btrfs_dev_replace_is_ongoing(dev_replace);
+        if (!dev_replace_is_ongoing)
+                btrfs_dev_replace_unlock(dev_replace);
+
+        if (dev_replace_is_ongoing && mirror_num == map->num_stripes + 1 &&
+            !(rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) &&
+            dev_replace->tgtdev != NULL) {
+                /*
+                 * in dev-replace case, for repair case (that's the only
+                 * case where the mirror is selected explicitly when
+                 * calling btrfs_map_block), blocks left of the left cursor
+                 * can also be read from the target drive.
+                 * For REQ_GET_READ_MIRRORS, the target drive is added as
+                 * the last one to the array of stripes. For READ, it also
+                 * needs to be supported using the same mirror number.
+                 * If the requested block is not left of the left cursor,
+                 * EIO is returned. This can happen because btrfs_num_copies()
+                 * returns one more in the dev-replace case.
+                 */
+                u64 tmp_length = *length;
+                struct btrfs_bio *tmp_bbio = NULL;
+                int tmp_num_stripes;
+                u64 srcdev_devid = dev_replace->srcdev->devid;
+                int index_srcdev = 0;
+                int found = 0;
+                u64 physical_of_found = 0;
+
+                ret = __btrfs_map_block(fs_info, REQ_GET_READ_MIRRORS,
+                             logical, &tmp_length, &tmp_bbio, 0);
+                if (ret) {
+                        WARN_ON(tmp_bbio != NULL);
+                        goto out;
+                }
+
+                tmp_num_stripes = tmp_bbio->num_stripes;
+                if (mirror_num > tmp_num_stripes) {
+                        /*
+                         * REQ_GET_READ_MIRRORS does not contain this
+                         * mirror, that means that the requested area
+                         * is not left of the left cursor
+                         */
+                        ret = -EIO;
+                        kfree(tmp_bbio);
+                        goto out;
+                }
+
+                /*
+                 * process the rest of the function using the mirror_num
+                 * of the source drive. Therefore look it up first.
+                 * At the end, patch the device pointer to the one of the
+                 * target drive.
+                 */
+                for (i = 0; i < tmp_num_stripes; i++) {
+                        if (tmp_bbio->stripes[i].dev->devid == srcdev_devid) {
+                                /*
+                                 * In case of DUP, in order to keep it
+                                 * simple, only add the mirror with the
+                                 * lowest physical address
+                                 */
+                                if (found &&
+                                    physical_of_found <=
+                                     tmp_bbio->stripes[i].physical)
+                                        continue;
+                                index_srcdev = i;
+                                found = 1;
+                                physical_of_found =
+                                        tmp_bbio->stripes[i].physical;
+                        }
+                }
+
+                if (found) {
+                        mirror_num = index_srcdev + 1;
+                        patch_the_first_stripe_for_dev_replace = 1;
+                        physical_to_patch_in_first_stripe = physical_of_found;
+                } else {
+                        WARN_ON(1);
+                        ret = -EIO;
+                        kfree(tmp_bbio);
+                        goto out;
+                }
+
+                kfree(tmp_bbio);
+        } else if (mirror_num > map->num_stripes) {
+                mirror_num = 0;
+        }
+
         num_stripes = 1;
         stripe_index = 0;
         stripe_nr_orig = stripe_nr;
@@ -3813,19 +4220,20 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                                             stripe_nr_end - stripe_nr_orig);
                 stripe_index = do_div(stripe_nr, map->num_stripes);
         } else if (map->type & BTRFS_BLOCK_GROUP_RAID1) {
-                if (rw & (REQ_WRITE | REQ_DISCARD))
+                if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS))
                         num_stripes = map->num_stripes;
                 else if (mirror_num)
                         stripe_index = mirror_num - 1;
                 else {
-                        stripe_index = find_live_mirror(map, 0,
+                        stripe_index = find_live_mirror(fs_info, map, 0,
                                             map->num_stripes,
-                                            current->pid % map->num_stripes);
+                                            current->pid % map->num_stripes,
+                                            dev_replace_is_ongoing);
                         mirror_num = stripe_index + 1;
                 }
 
         } else if (map->type & BTRFS_BLOCK_GROUP_DUP) {
-                if (rw & (REQ_WRITE | REQ_DISCARD)) {
+                if (rw & (REQ_WRITE | REQ_DISCARD | REQ_GET_READ_MIRRORS)) {
                         num_stripes = map->num_stripes;
                 } else if (mirror_num) {
                         stripe_index = mirror_num - 1;
@@ -3839,7 +4247,7 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                 stripe_index = do_div(stripe_nr, factor);
                 stripe_index *= map->sub_stripes;
 
-                if (rw & REQ_WRITE)
+                if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS))
                         num_stripes = map->sub_stripes;
                 else if (rw & REQ_DISCARD)
                         num_stripes = min_t(u64, map->sub_stripes *
@@ -3849,9 +4257,11 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                         stripe_index += mirror_num - 1;
                 else {
                         int old_stripe_index = stripe_index;
-                        stripe_index = find_live_mirror(map, stripe_index,
+                        stripe_index = find_live_mirror(fs_info, map,
+                                              stripe_index,
                                               map->sub_stripes, stripe_index +
-                                              current->pid % map->sub_stripes);
+                                              current->pid % map->sub_stripes,
+                                              dev_replace_is_ongoing);
                         mirror_num = stripe_index - old_stripe_index + 1;
                 }
         } else {
@@ -3865,7 +4275,14 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
         }
         BUG_ON(stripe_index >= map->num_stripes);
 
-        bbio = kzalloc(btrfs_bio_size(num_stripes), GFP_NOFS);
+        num_alloc_stripes = num_stripes;
+        if (dev_replace_is_ongoing) {
+                if (rw & (REQ_WRITE | REQ_DISCARD))
+                        num_alloc_stripes <<= 1;
+                if (rw & REQ_GET_READ_MIRRORS)
+                        num_alloc_stripes++;
+        }
+        bbio = kzalloc(btrfs_bio_size(num_alloc_stripes), GFP_NOFS);
         if (!bbio) {
                 ret = -ENOMEM;
                 goto out;
@@ -3952,7 +4369,7 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                 }
         }
 
-        if (rw & REQ_WRITE) {
+        if (rw & (REQ_WRITE | REQ_GET_READ_MIRRORS)) {
                 if (map->type & (BTRFS_BLOCK_GROUP_RAID1 |
                                  BTRFS_BLOCK_GROUP_RAID10 |
                                  BTRFS_BLOCK_GROUP_DUP)) {
@@ -3960,20 +4377,115 @@ static int __btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
                 }
         }
 
+        if (dev_replace_is_ongoing && (rw & (REQ_WRITE | REQ_DISCARD)) &&
+            dev_replace->tgtdev != NULL) {
+                int index_where_to_add;
+                u64 srcdev_devid = dev_replace->srcdev->devid;
+
+                /*
+                 * duplicate the write operations while the dev replace
+                 * procedure is running. Since the copying of the old disk
+                 * to the new disk takes place at run time while the
+                 * filesystem is mounted writable, the regular write
+                 * operations to the old disk have to be duplicated to go
+                 * to the new disk as well.
+                 * Note that device->missing is handled by the caller, and
+                 * that the write to the old disk is already set up in the
+                 * stripes array.
+                 */
+                index_where_to_add = num_stripes;
+                for (i = 0; i < num_stripes; i++) {
+                        if (bbio->stripes[i].dev->devid == srcdev_devid) {
+                                /* write to new disk, too */
+                                struct btrfs_bio_stripe *new =
+                                        bbio->stripes + index_where_to_add;
+                                struct btrfs_bio_stripe *old =
+                                        bbio->stripes + i;
+
+                                new->physical = old->physical;
+                                new->length = old->length;
+                                new->dev = dev_replace->tgtdev;
+                                index_where_to_add++;
+                                max_errors++;
+                        }
+                }
+                num_stripes = index_where_to_add;
+        } else if (dev_replace_is_ongoing && (rw & REQ_GET_READ_MIRRORS) &&
+                   dev_replace->tgtdev != NULL) {
+                u64 srcdev_devid = dev_replace->srcdev->devid;
+                int index_srcdev = 0;
+                int found = 0;
+                u64 physical_of_found = 0;
+
+                /*
+                 * During the dev-replace procedure, the target drive can
+                 * also be used to read data in case it is needed to repair
+                 * a corrupt block elsewhere. This is possible if the
+                 * requested area is left of the left cursor. In this area,
+                 * the target drive is a full copy of the source drive.
+                 */
+                for (i = 0; i < num_stripes; i++) {
+                        if (bbio->stripes[i].dev->devid == srcdev_devid) {
+                                /*
+                                 * In case of DUP, in order to keep it
+                                 * simple, only add the mirror with the
+                                 * lowest physical address
+                                 */
+                                if (found &&
+                                    physical_of_found <=
+                                     bbio->stripes[i].physical)
+                                        continue;
+                                index_srcdev = i;
+                                found = 1;
+                                physical_of_found = bbio->stripes[i].physical;
+                        }
+                }
+                if (found) {
+                        u64 length = map->stripe_len;
+
+                        if (physical_of_found + length <=
+                            dev_replace->cursor_left) {
+                                struct btrfs_bio_stripe *tgtdev_stripe =
+                                        bbio->stripes + num_stripes;
+
+                                tgtdev_stripe->physical = physical_of_found;
+                                tgtdev_stripe->length =
+                                        bbio->stripes[index_srcdev].length;
+                                tgtdev_stripe->dev = dev_replace->tgtdev;
+
+                                num_stripes++;
+                        }
+                }
+        }
+
         *bbio_ret = bbio;
         bbio->num_stripes = num_stripes;
         bbio->max_errors = max_errors;
         bbio->mirror_num = mirror_num;
+
+        /*
+         * this is the case that REQ_READ && dev_replace_is_ongoing &&
+         * mirror_num == num_stripes + 1 && dev_replace target drive is
+         * available as a mirror
+         */
+        if (patch_the_first_stripe_for_dev_replace && num_stripes > 0) {
+                WARN_ON(num_stripes > 1);
+                bbio->stripes[0].dev = dev_replace->tgtdev;
+                bbio->stripes[0].physical = physical_to_patch_in_first_stripe;
+                bbio->mirror_num = map->num_stripes + 1;
+        }
 out:
+        if (dev_replace_is_ongoing)
+                btrfs_dev_replace_unlock(dev_replace);
         free_extent_map(em);
         return ret;
 }
 
-int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                       u64 logical, u64 *length,
                       struct btrfs_bio **bbio_ret, int mirror_num)
 {
-        return __btrfs_map_block(map_tree, rw, logical, length, bbio_ret,
+        return __btrfs_map_block(fs_info, rw, logical, length, bbio_ret,
                                  mirror_num);
 }
 
@@ -4192,10 +4704,116 @@ static noinline void schedule_bio(struct btrfs_root *root,
                                    &device->work);
 }
 
+static int bio_size_ok(struct block_device *bdev, struct bio *bio,
+                       sector_t sector)
+{
+        struct bio_vec *prev;
+        struct request_queue *q = bdev_get_queue(bdev);
+        unsigned short 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) {
+                WARN_ON(1);
+                return 1;
+        }
+
+        prev = &bio->bi_io_vec[bio->bi_vcnt - 1];
+        if ((bio->bi_size >> 9) > max_sectors)
+                return 0;
+
+        if (!q->merge_bvec_fn)
+                return 1;
+
+        bvm.bi_size = bio->bi_size - prev->bv_len;
+        if (q->merge_bvec_fn(q, &bvm, prev) < prev->bv_len)
+                return 0;
+        return 1;
+}
+
+static void submit_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
+                              struct bio *bio, u64 physical, int dev_nr,
+                              int rw, int async)
+{
+        struct btrfs_device *dev = bbio->stripes[dev_nr].dev;
+
+        bio->bi_private = bbio;
+        bio->bi_private = merge_stripe_index_into_bio_private(
+                        bio->bi_private, (unsigned int)dev_nr);
+        bio->bi_end_io = btrfs_end_bio;
+        bio->bi_sector = physical >> 9;
+#ifdef DEBUG
+        {
+                struct rcu_string *name;
+
+                rcu_read_lock();
+                name = rcu_dereference(dev->name);
+                pr_debug("btrfs_map_bio: rw %d, sector=%llu, dev=%lu "
+                         "(%s id %llu), size=%u\n", rw,
+                         (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
+                         name->str, dev->devid, bio->bi_size);
+                rcu_read_unlock();
+        }
+#endif
+        bio->bi_bdev = dev->bdev;
+        if (async)
+                schedule_bio(root, dev, rw, bio);
+        else
+                btrfsic_submit_bio(rw, bio);
+}
+
+static int breakup_stripe_bio(struct btrfs_root *root, struct btrfs_bio *bbio,
+                              struct bio *first_bio, struct btrfs_device *dev,
+                              int dev_nr, int rw, int async)
+{
+        struct bio_vec *bvec = first_bio->bi_io_vec;
+        struct bio *bio;
+        int nr_vecs = bio_get_nr_vecs(dev->bdev);
+        u64 physical = bbio->stripes[dev_nr].physical;
+
+again:
+        bio = btrfs_bio_alloc(dev->bdev, physical >> 9, nr_vecs, GFP_NOFS);
+        if (!bio)
+                return -ENOMEM;
+
+        while (bvec <= (first_bio->bi_io_vec + first_bio->bi_vcnt - 1)) {
+                if (bio_add_page(bio, bvec->bv_page, bvec->bv_len,
+                                 bvec->bv_offset) < bvec->bv_len) {
+                        u64 len = bio->bi_size;
+
+                        atomic_inc(&bbio->stripes_pending);
+                        submit_stripe_bio(root, bbio, bio, physical, dev_nr,
+                                          rw, async);
+                        physical += len;
+                        goto again;
+                }
+                bvec++;
+        }
+
+        submit_stripe_bio(root, bbio, bio, physical, dev_nr, rw, async);
+        return 0;
+}
+
+static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
+{
+        atomic_inc(&bbio->error);
+        if (atomic_dec_and_test(&bbio->stripes_pending)) {
+                bio->bi_private = bbio->private;
+                bio->bi_end_io = bbio->end_io;
+                bio->bi_bdev = (struct block_device *)
+                        (unsigned long)bbio->mirror_num;
+                bio->bi_sector = logical >> 9;
+                kfree(bbio);
+                bio_endio(bio, -EIO);
+        }
+}
+
 int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
                   int mirror_num, int async_submit)
 {
-        struct btrfs_mapping_tree *map_tree;
         struct btrfs_device *dev;
         struct bio *first_bio = bio;
         u64 logical = (u64)bio->bi_sector << 9;
@@ -4207,17 +4825,16 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
         struct btrfs_bio *bbio = NULL;
 
         length = bio->bi_size;
-        map_tree = &root->fs_info->mapping_tree;
         map_length = length;
 
-        ret = btrfs_map_block(map_tree, rw, logical, &map_length, &bbio,
+        ret = btrfs_map_block(root->fs_info, rw, logical, &map_length, &bbio,
                               mirror_num);
-        if (ret) /* -ENOMEM */
+        if (ret)
                 return ret;
 
         total_devs = bbio->num_stripes;
         if (map_length < length) {
-                printk(KERN_CRIT "mapping failed logical %llu bio len %llu "
+                printk(KERN_CRIT "btrfs: mapping failed logical %llu bio len %llu "
                        "len %llu\n", (unsigned long long)logical,
                        (unsigned long long)length,
                        (unsigned long long)map_length);
@@ -4230,52 +4847,48 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio,
         atomic_set(&bbio->stripes_pending, bbio->num_stripes);
 
         while (dev_nr < total_devs) {
+                dev = bbio->stripes[dev_nr].dev;
+                if (!dev || !dev->bdev || (rw & WRITE && !dev->writeable)) {
+                        bbio_error(bbio, first_bio, logical);
+                        dev_nr++;
+                        continue;
+                }
+
+                /*
+                 * Check and see if we're ok with this bio based on it's size
+                 * and offset with the given device.
+                 */
+                if (!bio_size_ok(dev->bdev, first_bio,
+                                 bbio->stripes[dev_nr].physical >> 9)) {
+                        ret = breakup_stripe_bio(root, bbio, first_bio, dev,
+                                                 dev_nr, rw, async_submit);
+                        BUG_ON(ret);
+                        dev_nr++;
+                        continue;
+                }
+
                 if (dev_nr < total_devs - 1) {
                         bio = bio_clone(first_bio, GFP_NOFS);
                         BUG_ON(!bio); /* -ENOMEM */
                 } else {
                         bio = first_bio;
                 }
-                bio->bi_private = bbio;
-                bio->bi_private = merge_stripe_index_into_bio_private(
-                                bio->bi_private, (unsigned int)dev_nr);
-                bio->bi_end_io = btrfs_end_bio;
-                bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;
-                dev = bbio->stripes[dev_nr].dev;
-                if (dev && dev->bdev && (rw != WRITE || dev->writeable)) {
-#ifdef DEBUG
-                        struct rcu_string *name;
-
-                        rcu_read_lock();
-                        name = rcu_dereference(dev->name);
-                        pr_debug("btrfs_map_bio: rw %d, secor=%llu, dev=%lu "
-                                 "(%s id %llu), size=%u\n", rw,
-                                 (u64)bio->bi_sector, (u_long)dev->bdev->bd_dev,
-                                 name->str, dev->devid, bio->bi_size);
-                        rcu_read_unlock();
-#endif
-                        bio->bi_bdev = dev->bdev;
-                        if (async_submit)
-                                schedule_bio(root, dev, rw, bio);
-                        else
-                                btrfsic_submit_bio(rw, bio);
-                } else {
-                        bio->bi_bdev = root->fs_info->fs_devices->latest_bdev;
-                        bio->bi_sector = logical >> 9;
-                        bio_endio(bio, -EIO);
-                }
+
+                submit_stripe_bio(root, bbio, bio,
+                                  bbio->stripes[dev_nr].physical, dev_nr, rw,
+                                  async_submit);
                 dev_nr++;
         }
         return 0;
 }
 
-struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
+struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
                                        u8 *uuid, u8 *fsid)
 {
         struct btrfs_device *device;
         struct btrfs_fs_devices *cur_devices;
 
-        cur_devices = root->fs_info->fs_devices;
+        cur_devices = fs_info->fs_devices;
         while (cur_devices) {
                 if (!fsid ||
                     !memcmp(cur_devices->fsid, fsid, BTRFS_UUID_SIZE)) {
@@ -4356,6 +4969,7 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
         em->bdev = (struct block_device *)map;
         em->start = logical;
         em->len = length;
+        em->orig_start = 0;
         em->block_start = 0;
         em->block_len = em->len;
 
@@ -4373,8 +4987,8 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key,
                 read_extent_buffer(leaf, uuid, (unsigned long)
                                    btrfs_stripe_dev_uuid_nr(chunk, i),
                                    BTRFS_UUID_SIZE);
-                map->stripes[i].dev = btrfs_find_device(root, devid, uuid,
-                                                        NULL);
+                map->stripes[i].dev = btrfs_find_device(root->fs_info, devid,
+                                                        uuid, NULL);
                 if (!map->stripes[i].dev && !btrfs_test_opt(root, DEGRADED)) {
                         kfree(map);
                         free_extent_map(em);
@@ -4415,6 +5029,8 @@ static void fill_device_from_item(struct extent_buffer *leaf,
         device->io_align = btrfs_device_io_align(leaf, dev_item);
         device->io_width = btrfs_device_io_width(leaf, dev_item);
         device->sector_size = btrfs_device_sector_size(leaf, dev_item);
+        WARN_ON(device->devid == BTRFS_DEV_REPLACE_DEVID);
+        device->is_tgtdev_for_dev_replace = 0;
 
         ptr = (unsigned long)btrfs_device_uuid(dev_item);
         read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE);
@@ -4492,7 +5108,7 @@ static int read_one_dev(struct btrfs_root *root,
                         return ret;
         }
 
-        device = btrfs_find_device(root, devid, dev_uuid, fs_uuid);
+        device = btrfs_find_device(root->fs_info, devid, dev_uuid, fs_uuid);
         if (!device || !device->bdev) {
                 if (!btrfs_test_opt(root, DEGRADED))
                         return -EIO;
@@ -4525,7 +5141,7 @@ static int read_one_dev(struct btrfs_root *root,
         fill_device_from_item(leaf, dev_item, device);
         device->dev_root = root->fs_info->dev_root;
         device->in_fs_metadata = 1;
-        if (device->writeable) {
+        if (device->writeable && !device->is_tgtdev_for_dev_replace) {
                 device->fs_devices->total_rw_bytes += device->total_bytes;
                 spin_lock(&root->fs_info->free_chunk_lock);
                 root->fs_info->free_chunk_space += device->total_bytes -
@@ -4884,7 +5500,7 @@ int btrfs_get_dev_stats(struct btrfs_root *root,
         int i;
 
         mutex_lock(&fs_devices->device_list_mutex);
-        dev = btrfs_find_device(root, stats->devid, NULL, NULL);
+        dev = btrfs_find_device(root->fs_info, stats->devid, NULL, NULL);
         mutex_unlock(&fs_devices->device_list_mutex);
 
         if (!dev) {
@@ -4912,3 +5528,21 @@ int btrfs_get_dev_stats(struct btrfs_root *root,
                 stats->nr_items = BTRFS_DEV_STAT_VALUES_MAX;
         return 0;
 }
+
+int btrfs_scratch_superblock(struct btrfs_device *device)
+{
+        struct buffer_head *bh;
+        struct btrfs_super_block *disk_super;
+
+        bh = btrfs_read_dev_super(device->bdev);
+        if (!bh)
+                return -EINVAL;
+        disk_super = (struct btrfs_super_block *)bh->b_data;
+
+        memset(&disk_super->magic, 0, sizeof(disk_super->magic));
+        set_buffer_dirty(bh);
+        sync_dirty_buffer(bh);
+        brelse(bh);
+
+        return 0;
+}
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 53c06af92e8d..d3c3939ac751 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -50,6 +50,7 @@ struct btrfs_device {
         int in_fs_metadata;
         int missing;
         int can_discard;
+        int is_tgtdev_for_dev_replace;
 
         spinlock_t io_lock;
 
@@ -88,7 +89,7 @@ struct btrfs_device {
         u8 uuid[BTRFS_UUID_SIZE];
 
         /* per-device scrub information */
-        struct scrub_dev *scrub_device;
+        struct scrub_ctx *scrub_device;
 
         struct btrfs_work work;
         struct rcu_head rcu;
@@ -179,6 +180,15 @@ struct btrfs_device_info {
         u64 total_avail;
 };
 
+struct btrfs_raid_attr {
+        int sub_stripes;        /* sub_stripes info for map */
+        int dev_stripes;        /* stripes per dev */
+        int devs_max;           /* max devs to use */
+        int devs_min;           /* min devs needed */
+        int devs_increment;     /* ndevs has to be a multiple of this */
+        int ncopies;            /* how many copies to data has */
+};
+
 struct map_lookup {
         u64 type;
         int io_align;
@@ -248,7 +258,7 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans,
                            struct btrfs_device *device,
                            u64 chunk_tree, u64 chunk_objectid,
                            u64 chunk_offset, u64 start, u64 num_bytes);
-int btrfs_map_block(struct btrfs_mapping_tree *map_tree, int rw,
+int btrfs_map_block(struct btrfs_fs_info *fs_info, int rw,
                     u64 logical, u64 *length,
                     struct btrfs_bio **bbio_ret, int mirror_num);
 int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
@@ -267,19 +277,27 @@ int btrfs_open_devices(struct btrfs_fs_devices *fs_devices,
 int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
                           struct btrfs_fs_devices **fs_devices_ret);
 int btrfs_close_devices(struct btrfs_fs_devices *fs_devices);
-void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices);
+void btrfs_close_extra_devices(struct btrfs_fs_info *fs_info,
+                               struct btrfs_fs_devices *fs_devices, int step);
+int btrfs_find_device_missing_or_by_path(struct btrfs_root *root,
+                                         char *device_path,
+                                         struct btrfs_device **device);
+int btrfs_find_device_by_path(struct btrfs_root *root, char *device_path,
+                              struct btrfs_device **device);
 int btrfs_add_device(struct btrfs_trans_handle *trans,
                      struct btrfs_root *root,
                      struct btrfs_device *device);
 int btrfs_rm_device(struct btrfs_root *root, char *device_path);
 void btrfs_cleanup_fs_uuids(void);
-int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len);
+int btrfs_num_copies(struct btrfs_fs_info *fs_info, u64 logical, u64 len);
 int btrfs_grow_device(struct btrfs_trans_handle *trans,
                       struct btrfs_device *device, u64 new_size);
-struct btrfs_device *btrfs_find_device(struct btrfs_root *root, u64 devid,
+struct btrfs_device *btrfs_find_device(struct btrfs_fs_info *fs_info, u64 devid,
                                        u8 *uuid, u8 *fsid);
 int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
 int btrfs_init_new_device(struct btrfs_root *root, char *path);
+int btrfs_init_dev_replace_tgtdev(struct btrfs_root *root, char *device_path,
+                                  struct btrfs_device **device_out);
 int btrfs_balance(struct btrfs_balance_control *bctl,
                   struct btrfs_ioctl_balance_args *bargs);
 int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
@@ -296,6 +314,13 @@ int btrfs_get_dev_stats(struct btrfs_root *root,
 int btrfs_init_dev_stats(struct btrfs_fs_info *fs_info);
 int btrfs_run_dev_stats(struct btrfs_trans_handle *trans,
                         struct btrfs_fs_info *fs_info);
+void btrfs_rm_dev_replace_srcdev(struct btrfs_fs_info *fs_info,
+                                 struct btrfs_device *srcdev);
+void btrfs_destroy_dev_replace_tgtdev(struct btrfs_fs_info *fs_info,
+                                      struct btrfs_device *tgtdev);
+void btrfs_init_dev_replace_tgtdev_for_resume(struct btrfs_fs_info *fs_info,
+                                              struct btrfs_device *tgtdev);
+int btrfs_scratch_superblock(struct btrfs_device *device);
 
 static inline void btrfs_dev_stat_inc(struct btrfs_device *dev,
                                       int index)
diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 3f4e2d69e83a..446a6848c554 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -122,6 +122,16 @@ static int do_setxattr(struct btrfs_trans_handle *trans,
                  */
                 if (!value)
                         goto out;
+        } else {
+                di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode),
+                                        name, name_len, 0);
+                if (IS_ERR(di)) {
+                        ret = PTR_ERR(di);
+                        goto out;
+                }
+                if (!di && !value)
+                        goto out;
+                btrfs_release_path(path);
         }
 
 again:
@@ -198,6 +208,7 @@ int __btrfs_setxattr(struct btrfs_trans_handle *trans,
 
         inode_inc_iversion(inode);
         inode->i_ctime = CURRENT_TIME;
+        set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
         ret = btrfs_update_inode(trans, root, inode);
         BUG_ON(ret);
 out:
@@ -265,7 +276,7 @@ ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 
                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
                 if (verify_dir_item(root, leaf, di))
-                        continue;
+                        goto next;
 
                 name_len = btrfs_dir_name_len(leaf, di);
                 total_size += name_len + 1;
diff --git a/fs/btrfs/zlib.c b/fs/btrfs/zlib.c
index 92c20654cc55..9acb846c3e7f 100644
--- a/fs/btrfs/zlib.c
+++ b/fs/btrfs/zlib.c
@@ -97,7 +97,7 @@ static int zlib_compress_pages(struct list_head *ws,
         *total_in = 0;
 
         if (Z_OK != zlib_deflateInit(&workspace->def_strm, 3)) {
-                printk(KERN_WARNING "deflateInit failed\n");
+                printk(KERN_WARNING "btrfs: deflateInit failed\n");
                 ret = -1;
                 goto out;
         }
@@ -125,7 +125,7 @@ static int zlib_compress_pages(struct list_head *ws,
         while (workspace->def_strm.total_in < len) {
                 ret = zlib_deflate(&workspace->def_strm, Z_SYNC_FLUSH);
                 if (ret != Z_OK) {
-                        printk(KERN_DEBUG "btrfs deflate in loop returned %d\n",
+                        printk(KERN_DEBUG "btrfs: deflate in loop returned %d\n",
                                ret);
                         zlib_deflateEnd(&workspace->def_strm);
                         ret = -1;
@@ -252,7 +252,7 @@ static int zlib_decompress_biovec(struct list_head *ws, struct page **pages_in,
         }
 
         if (Z_OK != zlib_inflateInit2(&workspace->inf_strm, wbits)) {
-                printk(KERN_WARNING "inflateInit failed\n");
+                printk(KERN_WARNING "btrfs: inflateInit failed\n");
                 return -1;
         }
         while (workspace->inf_strm.total_in < srclen) {
@@ -336,7 +336,7 @@ static int zlib_decompress(struct list_head *ws, unsigned char *data_in,
         }
 
         if (Z_OK != zlib_inflateInit2(&workspace->inf_strm, wbits)) {
-                printk(KERN_WARNING "inflateInit failed\n");
+                printk(KERN_WARNING "btrfs: inflateInit failed\n");
                 return -1;
         }