Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 1309 insertions, 898 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index c03864406af3..3601f0aebddf 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -37,6 +37,7 @@
 #include <linux/posix_acl.h>
 #include <linux/falloc.h>
 #include <linux/slab.h>
+#include <linux/ratelimit.h>
 #include "compat.h"
 #include "ctree.h"
 #include "disk-io.h"
@@ -50,6 +51,8 @@
 #include "tree-log.h"
 #include "compression.h"
 #include "locking.h"
+#include "free-space-cache.h"
+#include "inode-map.h"
 
 struct btrfs_iget_args {
         u64 ino;
@@ -70,6 +73,7 @@ static struct kmem_cache *btrfs_inode_cachep;
 struct kmem_cache *btrfs_trans_handle_cachep;
 struct kmem_cache *btrfs_transaction_cachep;
 struct kmem_cache *btrfs_path_cachep;
+struct kmem_cache *btrfs_free_space_cachep;
 
 #define S_SHIFT 12
 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
@@ -82,7 +86,8 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
         [S_IFLNK >> S_SHIFT]    = BTRFS_FT_SYMLINK,
 };
 
-static void btrfs_truncate(struct inode *inode);
+static int btrfs_setsize(struct inode *inode, loff_t newsize);
+static int btrfs_truncate(struct inode *inode);
 static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
 static noinline int cow_file_range(struct inode *inode,
                                    struct page *locked_page,
@@ -90,13 +95,14 @@ static noinline int cow_file_range(struct inode *inode,
                                    unsigned long *nr_written, int unlock);
 
 static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
-                                     struct inode *inode,  struct inode *dir)
+                                     struct inode *inode,  struct inode *dir,
+                                     const struct qstr *qstr)
 {
         int err;
 
         err = btrfs_init_acl(trans, inode, dir);
         if (!err)
-                err = btrfs_xattr_security_init(trans, inode, dir);
+                err = btrfs_xattr_security_init(trans, inode, dir, qstr);
         return err;
 }
 
@@ -108,6 +114,7 @@ static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,
 static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root, struct inode *inode,
                                 u64 start, size_t size, size_t compressed_size,
+                                int compress_type,
                                 struct page **compressed_pages)
 {
         struct btrfs_key key;
@@ -122,21 +129,17 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
         size_t cur_size = size;
         size_t datasize;
         unsigned long offset;
-        int use_compress = 0;
 
-        if (compressed_size && compressed_pages) {
-                use_compress = 1;
+        if (compressed_size && compressed_pages)
                 cur_size = compressed_size;
-        }
 
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
 
         path->leave_spinning = 1;
-        btrfs_set_trans_block_group(trans, inode);
 
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         key.offset = start;
         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
         datasize = btrfs_file_extent_calc_inline_size(cur_size);
@@ -159,7 +162,7 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
         btrfs_set_file_extent_ram_bytes(leaf, ei, size);
         ptr = btrfs_file_extent_inline_start(ei);
 
-        if (use_compress) {
+        if (compress_type != BTRFS_COMPRESS_NONE) {
                 struct page *cpage;
                 int i = 0;
                 while (compressed_size > 0) {
@@ -176,7 +179,7 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
                         compressed_size -= cur_size;
                 }
                 btrfs_set_file_extent_compression(leaf, ei,
-                                                  BTRFS_COMPRESS_ZLIB);
+                                                  compress_type);
         } else {
                 page = find_get_page(inode->i_mapping,
                                      start >> PAGE_CACHE_SHIFT);
@@ -217,7 +220,7 @@ fail:
 static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                                  struct btrfs_root *root,
                                  struct inode *inode, u64 start, u64 end,
-                                 size_t compressed_size,
+                                 size_t compressed_size, int compress_type,
                                  struct page **compressed_pages)
 {
         u64 isize = i_size_read(inode);
@@ -250,7 +253,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
                 inline_len = min_t(u64, isize, actual_end);
         ret = insert_inline_extent(trans, root, inode, start,
                                    inline_len, compressed_size,
-                                   compressed_pages);
+                                   compress_type, compressed_pages);
         BUG_ON(ret);
         btrfs_delalloc_release_metadata(inode, end + 1 - start);
         btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
@@ -263,6 +266,7 @@ struct async_extent {
         u64 compressed_size;
         struct page **pages;
         unsigned long nr_pages;
+        int compress_type;
         struct list_head list;
 };
 
@@ -280,16 +284,19 @@ static noinline int add_async_extent(struct async_cow *cow,
                                      u64 start, u64 ram_size,
                                      u64 compressed_size,
                                      struct page **pages,
-                                     unsigned long nr_pages)
+                                     unsigned long nr_pages,
+                                     int compress_type)
 {
         struct async_extent *async_extent;
 
         async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);
+        BUG_ON(!async_extent);
         async_extent->start = start;
         async_extent->ram_size = ram_size;
         async_extent->compressed_size = compressed_size;
         async_extent->pages = pages;
         async_extent->nr_pages = nr_pages;
+        async_extent->compress_type = compress_type;
         list_add_tail(&async_extent->list, &cow->extents);
         return 0;
 }
@@ -319,8 +326,6 @@ static noinline int compress_file_range(struct inode *inode,
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         u64 num_bytes;
-        u64 orig_start;
-        u64 disk_num_bytes;
         u64 blocksize = root->sectorsize;
         u64 actual_end;
         u64 isize = i_size_read(inode);
@@ -334,8 +339,11 @@ static noinline int compress_file_range(struct inode *inode,
         unsigned long max_uncompressed = 128 * 1024;
         int i;
         int will_compress;
+        int compress_type = root->fs_info->compress_type;
 
-        orig_start = start;
+        /* if this is a small write inside eof, kick off a defragbot */
+        if (end <= BTRFS_I(inode)->disk_i_size && (end - start + 1) < 16 * 1024)
+                btrfs_add_inode_defrag(NULL, inode);
 
         actual_end = min_t(u64, isize, end + 1);
 again:
@@ -371,7 +379,6 @@ again:
         total_compressed = min(total_compressed, max_uncompressed);
         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
         num_bytes = max(blocksize,  num_bytes);
-        disk_num_bytes = num_bytes;
         total_in = 0;
         ret = 0;
 
@@ -382,16 +389,22 @@ again:
          */
         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&
             (btrfs_test_opt(root, COMPRESS) ||
-             (BTRFS_I(inode)->force_compress))) {
+             (BTRFS_I(inode)->force_compress) ||
+             (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {
                 WARN_ON(pages);
                 pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
+                BUG_ON(!pages);
+
+                if (BTRFS_I(inode)->force_compress)
+                        compress_type = BTRFS_I(inode)->force_compress;
 
-                ret = btrfs_zlib_compress_pages(inode->i_mapping, start,
-                                                total_compressed, pages,
-                                                nr_pages, &nr_pages_ret,
-                                                &total_in,
-                                                &total_compressed,
-                                                max_compressed);
+                ret = btrfs_compress_pages(compress_type,
+                                           inode->i_mapping, start,
+                                           total_compressed, pages,
+                                           nr_pages, &nr_pages_ret,
+                                           &total_in,
+                                           &total_compressed,
+                                           max_compressed);
 
                 if (!ret) {
                         unsigned long offset = total_compressed &
@@ -412,9 +425,8 @@ again:
                 }
         }
         if (start == 0) {
-                trans = btrfs_join_transaction(root, 1);
-                BUG_ON(!trans);
-                btrfs_set_trans_block_group(trans, inode);
+                trans = btrfs_join_transaction(root);
+                BUG_ON(IS_ERR(trans));
                 trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
                 /* lets try to make an inline extent */
@@ -423,12 +435,13 @@ again:
                          * to make an uncompressed inline extent.
                          */
                         ret = cow_file_range_inline(trans, root, inode,
-                                                    start, end, 0, NULL);
+                                                    start, end, 0, 0, NULL);
                 } else {
                         /* try making a compressed inline extent */
                         ret = cow_file_range_inline(trans, root, inode,
                                                     start, end,
-                                                    total_compressed, pages);
+                                                    total_compressed,
+                                                    compress_type, pages);
                 }
                 if (ret == 0) {
                         /*
@@ -467,7 +480,6 @@ again:
                 if (total_compressed >= total_in) {
                         will_compress = 0;
                 } else {
-                        disk_num_bytes = total_compressed;
                         num_bytes = total_in;
                 }
         }
@@ -499,9 +511,10 @@ again:
                  * and will submit them to the elevator.
                  */
                 add_async_extent(async_cow, start, num_bytes,
-                                 total_compressed, pages, nr_pages_ret);
+                                 total_compressed, pages, nr_pages_ret,
+                                 compress_type);
 
-                if (start + num_bytes < end && start + num_bytes < actual_end) {
+                if (start + num_bytes < end) {
                         start += num_bytes;
                         pages = NULL;
                         cond_resched();
@@ -521,7 +534,8 @@ cleanup_and_bail_uncompressed:
                         __set_page_dirty_nobuffers(locked_page);
                         /* unlocked later on in the async handlers */
                 }
-                add_async_extent(async_cow, start, end - start + 1, 0, NULL, 0);
+                add_async_extent(async_cow, start, end - start + 1,
+                                 0, NULL, 0, BTRFS_COMPRESS_NONE);
                 *num_added += 1;
         }
 
@@ -607,7 +621,9 @@ retry:
                             async_extent->start + async_extent->ram_size - 1,
                             GFP_NOFS);
 
-                trans = btrfs_join_transaction(root, 1);
+                trans = btrfs_join_transaction(root);
+                BUG_ON(IS_ERR(trans));
+                trans->block_rsv = &root->fs_info->delalloc_block_rsv;
                 ret = btrfs_reserve_extent(trans, root,
                                            async_extent->compressed_size,
                                            async_extent->compressed_size,
@@ -638,7 +654,8 @@ retry:
                                         async_extent->start +
                                         async_extent->ram_size - 1, 0);
 
-                em = alloc_extent_map(GFP_NOFS);
+                em = alloc_extent_map();
+                BUG_ON(!em);
                 em->start = async_extent->start;
                 em->len = async_extent->ram_size;
                 em->orig_start = em->start;
@@ -646,6 +663,7 @@ retry:
                 em->block_start = ins.objectid;
                 em->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);
 
@@ -662,11 +680,13 @@ retry:
                                                 async_extent->ram_size - 1, 0);
                 }
 
-                ret = btrfs_add_ordered_extent(inode, async_extent->start,
-                                               ins.objectid,
-                                               async_extent->ram_size,
-                                               ins.offset,
-                                               BTRFS_ORDERED_COMPRESSED);
+                ret = btrfs_add_ordered_extent_compress(inode,
+                                                async_extent->start,
+                                                ins.objectid,
+                                                async_extent->ram_size,
+                                                ins.offset,
+                                                BTRFS_ORDERED_COMPRESSED,
+                                                async_extent->compress_type);
                 BUG_ON(ret);
 
                 /*
@@ -730,6 +750,15 @@ static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
         return alloc_hint;
 }
 
+static inline bool is_free_space_inode(struct btrfs_root *root,
+                                       struct inode *inode)
+{
+        if (root == root->fs_info->tree_root ||
+            BTRFS_I(inode)->location.objectid == BTRFS_FREE_INO_OBJECTID)
+                return true;
+        return false;
+}
+
 /*
  * when extent_io.c finds a delayed allocation range in the file,
  * the call backs end up in this code.  The basic idea is to
@@ -757,29 +786,29 @@ static noinline int cow_file_range(struct inode *inode,
         u64 disk_num_bytes;
         u64 cur_alloc_size;
         u64 blocksize = root->sectorsize;
-        u64 actual_end;
-        u64 isize = i_size_read(inode);
         struct btrfs_key ins;
         struct extent_map *em;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         int ret = 0;
 
-        trans = btrfs_join_transaction(root, 1);
-        BUG_ON(!trans);
-        btrfs_set_trans_block_group(trans, inode);
+        BUG_ON(is_free_space_inode(root, inode));
+        trans = btrfs_join_transaction(root);
+        BUG_ON(IS_ERR(trans));
         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
-        actual_end = min_t(u64, isize, end + 1);
-
         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 (end <= BTRFS_I(inode)->disk_i_size && num_bytes < 64 * 1024)
+                btrfs_add_inode_defrag(trans, inode);
+
         if (start == 0) {
                 /* lets try to make an inline extent */
                 ret = cow_file_range_inline(trans, root, inode,
-                                            start, end, 0, NULL);
+                                            start, end, 0, 0, NULL);
                 if (ret == 0) {
                         extent_clear_unlock_delalloc(inode,
                                      &BTRFS_I(inode)->io_tree,
@@ -814,7 +843,8 @@ static noinline int cow_file_range(struct inode *inode,
                                            (u64)-1, &ins, 1);
                 BUG_ON(ret);
 
-                em = alloc_extent_map(GFP_NOFS);
+                em = alloc_extent_map();
+                BUG_ON(!em);
                 em->start = start;
                 em->orig_start = em->start;
                 ram_size = ins.offset;
@@ -941,6 +971,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
                          1, 0, NULL, GFP_NOFS);
         while (start < end) {
                 async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
+                BUG_ON(!async_cow);
                 async_cow->inode = inode;
                 async_cow->root = root;
                 async_cow->locked_page = locked_page;
@@ -994,7 +1025,7 @@ static noinline int csum_exist_in_range(struct btrfs_root *root,
         LIST_HEAD(list);
 
         ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,
-                                       bytenr + num_bytes - 1, &list);
+                                       bytenr + num_bytes - 1, &list, 0);
         if (ret == 0 && list_empty(&list))
                 return 0;
 
@@ -1035,23 +1066,33 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         int type;
         int nocow;
         int check_prev = 1;
+        bool nolock;
+        u64 ino = btrfs_ino(inode);
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
-        trans = btrfs_join_transaction(root, 1);
-        BUG_ON(!trans);
+
+        nolock = is_free_space_inode(root, inode);
+
+        if (nolock)
+                trans = btrfs_join_transaction_nolock(root);
+        else
+                trans = btrfs_join_transaction(root);
+
+        BUG_ON(IS_ERR(trans));
+        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
         cow_start = (u64)-1;
         cur_offset = start;
         while (1) {
-                ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
+                ret = btrfs_lookup_file_extent(trans, root, path, ino,
                                                cur_offset, 0);
                 BUG_ON(ret < 0);
                 if (ret > 0 && path->slots[0] > 0 && check_prev) {
                         leaf = path->nodes[0];
                         btrfs_item_key_to_cpu(leaf, &found_key,
                                               path->slots[0] - 1);
-                        if (found_key.objectid == inode->i_ino &&
+                        if (found_key.objectid == ino &&
                             found_key.type == BTRFS_EXTENT_DATA_KEY)
                                 path->slots[0]--;
                 }
@@ -1072,7 +1113,7 @@ next_slot:
                 num_bytes = 0;
                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 
-                if (found_key.objectid > inode->i_ino ||
+                if (found_key.objectid > ino ||
                     found_key.type > BTRFS_EXTENT_DATA_KEY ||
                     found_key.offset > end)
                         break;
@@ -1107,7 +1148,7 @@ next_slot:
                                 goto out_check;
                         if (btrfs_extent_readonly(root, disk_bytenr))
                                 goto out_check;
-                        if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
+                        if (btrfs_cross_ref_exist(trans, root, ino,
                                                   found_key.offset -
                                                   extent_offset, disk_bytenr))
                                 goto out_check;
@@ -1144,7 +1185,7 @@ out_check:
                         goto next_slot;
                 }
 
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
                 if (cow_start != (u64)-1) {
                         ret = cow_file_range(inode, locked_page, cow_start,
                                         found_key.offset - 1, page_started,
@@ -1157,7 +1198,8 @@ out_check:
                         struct extent_map *em;
                         struct extent_map_tree *em_tree;
                         em_tree = &BTRFS_I(inode)->extent_tree;
-                        em = alloc_extent_map(GFP_NOFS);
+                        em = alloc_extent_map();
+                        BUG_ON(!em);
                         em->start = cur_offset;
                         em->orig_start = em->start;
                         em->len = num_bytes;
@@ -1201,7 +1243,7 @@ out_check:
                 if (cur_offset > end)
                         break;
         }
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         if (cur_offset <= end && cow_start == (u64)-1)
                 cow_start = cur_offset;
@@ -1211,8 +1253,13 @@ out_check:
                 BUG_ON(ret);
         }
 
-        ret = btrfs_end_transaction(trans, root);
-        BUG_ON(ret);
+        if (nolock) {
+                ret = btrfs_end_transaction_nolock(trans, root);
+                BUG_ON(ret);
+        } else {
+                ret = btrfs_end_transaction(trans, root);
+                BUG_ON(ret);
+        }
         btrfs_free_path(path);
         return 0;
 }
@@ -1234,7 +1281,8 @@ static int run_delalloc_range(struct inode *inode, struct page *locked_page,
                 ret = run_delalloc_nocow(inode, locked_page, start, end,
                                          page_started, 0, nr_written);
         else if (!btrfs_test_opt(root, COMPRESS) &&
-                 !(BTRFS_I(inode)->force_compress))
+                 !(BTRFS_I(inode)->force_compress) &&
+                 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))
                 ret = cow_file_range(inode, locked_page, start, end,
                                       page_started, nr_written, 1);
         else
@@ -1283,12 +1331,13 @@ static int btrfs_set_bit_hook(struct inode *inode,
 
         /*
          * set_bit and clear bit hooks normally require _irqsave/restore
-         * but in this case, we are only testeing for the DELALLOC
+         * but in this case, we are only testing for the DELALLOC
          * bit, which is only set or cleared with irqs on
          */
         if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
                 struct btrfs_root *root = BTRFS_I(inode)->root;
                 u64 len = state->end + 1 - state->start;
+                bool do_list = !is_free_space_inode(root, inode);
 
                 if (*bits & EXTENT_FIRST_DELALLOC)
                         *bits &= ~EXTENT_FIRST_DELALLOC;
@@ -1298,7 +1347,7 @@ static int btrfs_set_bit_hook(struct inode *inode,
                 spin_lock(&root->fs_info->delalloc_lock);
                 BTRFS_I(inode)->delalloc_bytes += len;
                 root->fs_info->delalloc_bytes += len;
-                if (list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
+                if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
                         list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
                                       &root->fs_info->delalloc_inodes);
                 }
@@ -1315,12 +1364,13 @@ static int btrfs_clear_bit_hook(struct inode *inode,
 {
         /*
          * set_bit and clear bit hooks normally require _irqsave/restore
-         * but in this case, we are only testeing for the DELALLOC
+         * but in this case, we are only testing for the DELALLOC
          * bit, which is only set or cleared with irqs on
          */
         if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {
                 struct btrfs_root *root = BTRFS_I(inode)->root;
                 u64 len = state->end + 1 - state->start;
+                bool do_list = !is_free_space_inode(root, inode);
 
                 if (*bits & EXTENT_FIRST_DELALLOC)
                         *bits &= ~EXTENT_FIRST_DELALLOC;
@@ -1330,14 +1380,15 @@ static int btrfs_clear_bit_hook(struct inode *inode,
                 if (*bits & EXTENT_DO_ACCOUNTING)
                         btrfs_delalloc_release_metadata(inode, len);
 
-                if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID)
+                if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
+                    && do_list)
                         btrfs_free_reserved_data_space(inode, len);
 
                 spin_lock(&root->fs_info->delalloc_lock);
                 root->fs_info->delalloc_bytes -= len;
                 BTRFS_I(inode)->delalloc_bytes -= len;
 
-                if (BTRFS_I(inode)->delalloc_bytes == 0 &&
+                if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&
                     !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
                         list_del_init(&BTRFS_I(inode)->delalloc_inodes);
                 }
@@ -1372,7 +1423,7 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
 
         if (map_length < length + size)
                 return 1;
-        return 0;
+        return ret;
 }
 
 /*
@@ -1426,15 +1477,21 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 
         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
-        ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
+        if (is_free_space_inode(root, inode))
+                ret = btrfs_bio_wq_end_io(root->fs_info, bio, 2);
+        else
+                ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
         BUG_ON(ret);
 
         if (!(rw & REQ_WRITE)) {
                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
                         return btrfs_submit_compressed_read(inode, bio,
                                                     mirror_num, bio_flags);
-                } else if (!skip_sum)
-                        btrfs_lookup_bio_sums(root, inode, bio, NULL);
+                } else if (!skip_sum) {
+                        ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
+                        if (ret)
+                                return ret;
+                }
                 goto mapit;
         } else if (!skip_sum) {
                 /* csum items have already been cloned */
@@ -1462,8 +1519,6 @@ static noinline int add_pending_csums(struct btrfs_trans_handle *trans,
 {
         struct btrfs_ordered_sum *sum;
 
-        btrfs_set_trans_block_group(trans, inode);
-
         list_for_each_entry(sum, list, list) {
                 btrfs_csum_file_blocks(trans,
                        BTRFS_I(inode)->root->fs_info->csum_root, sum);
@@ -1534,6 +1589,7 @@ out:
 out_page:
         unlock_page(page);
         page_cache_release(page);
+        kfree(fixup);
 }
 
 /*
@@ -1605,7 +1661,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
                                  &hint, 0);
         BUG_ON(ret);
 
-        ins.objectid = inode->i_ino;
+        ins.objectid = btrfs_ino(inode);
         ins.offset = file_pos;
         ins.type = BTRFS_EXTENT_DATA_KEY;
         ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
@@ -1636,7 +1692,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         ins.type = BTRFS_EXTENT_ITEM_KEY;
         ret = btrfs_alloc_reserved_file_extent(trans, root,
                                         root->root_key.objectid,
-                                        inode->i_ino, file_pos, &ins);
+                                        btrfs_ino(inode), file_pos, &ins);
         BUG_ON(ret);
         btrfs_free_path(path);
 
@@ -1660,8 +1716,9 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
         struct btrfs_ordered_extent *ordered_extent = NULL;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct extent_state *cached_state = NULL;
-        int compressed = 0;
+        int compress_type = 0;
         int ret;
+        bool nolock;
 
         ret = btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
                                              end - start + 1);
@@ -1669,12 +1726,17 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
                 return 0;
         BUG_ON(!ordered_extent);
 
+        nolock = is_free_space_inode(root, inode);
+
         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
                 BUG_ON(!list_empty(&ordered_extent->list));
                 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
                 if (!ret) {
-                        trans = btrfs_join_transaction(root, 1);
-                        btrfs_set_trans_block_group(trans, inode);
+                        if (nolock)
+                                trans = btrfs_join_transaction_nolock(root);
+                        else
+                                trans = btrfs_join_transaction(root);
+                        BUG_ON(IS_ERR(trans));
                         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
                         ret = btrfs_update_inode(trans, root, inode);
                         BUG_ON(ret);
@@ -1686,27 +1748,31 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
                          ordered_extent->file_offset + ordered_extent->len - 1,
                          0, &cached_state, GFP_NOFS);
 
-        trans = btrfs_join_transaction(root, 1);
-        btrfs_set_trans_block_group(trans, inode);
+        if (nolock)
+                trans = btrfs_join_transaction_nolock(root);
+        else
+                trans = btrfs_join_transaction(root);
+        BUG_ON(IS_ERR(trans));
         trans->block_rsv = &root->fs_info->delalloc_block_rsv;
 
         if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
-                compressed = 1;
+                compress_type = ordered_extent->compress_type;
         if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) {
-                BUG_ON(compressed);
+                BUG_ON(compress_type);
                 ret = btrfs_mark_extent_written(trans, inode,
                                                 ordered_extent->file_offset,
                                                 ordered_extent->file_offset +
                                                 ordered_extent->len);
                 BUG_ON(ret);
         } else {
+                BUG_ON(root == root->fs_info->tree_root);
                 ret = insert_reserved_file_extent(trans, inode,
                                                 ordered_extent->file_offset,
                                                 ordered_extent->start,
                                                 ordered_extent->disk_len,
                                                 ordered_extent->len,
                                                 ordered_extent->len,
-                                                compressed, 0, 0,
+                                                compress_type, 0, 0,
                                                 BTRFS_FILE_EXTENT_REG);
                 unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
                                    ordered_extent->file_offset,
@@ -1720,13 +1786,22 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
         add_pending_csums(trans, inode, ordered_extent->file_offset,
                           &ordered_extent->list);
 
-        btrfs_ordered_update_i_size(inode, 0, ordered_extent);
-        ret = btrfs_update_inode(trans, root, inode);
-        BUG_ON(ret);
+        ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
+        if (!ret) {
+                ret = btrfs_update_inode(trans, root, inode);
+                BUG_ON(ret);
+        }
+        ret = 0;
 out:
-        btrfs_delalloc_release_metadata(inode, ordered_extent->len);
-        if (trans)
-                btrfs_end_transaction(trans, root);
+        if (nolock) {
+                if (trans)
+                        btrfs_end_transaction_nolock(trans, root);
+        } else {
+                btrfs_delalloc_release_metadata(inode, ordered_extent->len);
+                if (trans)
+                        btrfs_end_transaction(trans, root);
+        }
+
         /* once for us */
         btrfs_put_ordered_extent(ordered_extent);
         /* once for the tree */
@@ -1738,6 +1813,8 @@ out:
 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
                                 struct extent_state *state, int uptodate)
 {
+        trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
+
         ClearPagePrivate2(page);
         return btrfs_finish_ordered_io(page->mapping->host, start, end);
 }
@@ -1793,7 +1870,7 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
                 }
                 read_unlock(&em_tree->lock);
 
-                if (!em || IS_ERR(em)) {
+                if (IS_ERR_OR_NULL(em)) {
                         kfree(failrec);
                         return -EIO;
                 }
@@ -1802,6 +1879,8 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
                 if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
                         logical = em->block_start;
                         failrec->bio_flags = EXTENT_BIO_COMPRESSED;
+                        extent_set_compress_type(&failrec->bio_flags,
+                                                 em->compress_type);
                 }
                 failrec->logical = logical;
                 free_extent_map(em);
@@ -1846,10 +1925,10 @@ static int btrfs_io_failed_hook(struct bio *failed_bio,
         else
                 rw = READ;
 
-        BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
+        ret = BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
                                                       failrec->last_mirror,
                                                       failrec->bio_flags, 0);
-        return 0;
+        return ret;
 }
 
 /*
@@ -1865,7 +1944,7 @@ static int btrfs_clean_io_failures(struct inode *inode, u64 start)
 
         private = 0;
         if (count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
-                             (u64)-1, 1, EXTENT_DIRTY)) {
+                             (u64)-1, 1, EXTENT_DIRTY, 0)) {
                 ret = get_state_private(&BTRFS_I(inode)->io_failure_tree,
                                         start, &private_failure);
                 if (ret == 0) {
@@ -1907,7 +1986,7 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
         }
 
         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
-                return 0;
+                goto good;
 
         if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
             test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
@@ -1940,12 +2019,11 @@ good:
         return 0;
 
 zeroit:
-        if (printk_ratelimit()) {
-                printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
-                       "private %llu\n", page->mapping->host->i_ino,
+        printk_ratelimited(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
+                       "private %llu\n",
+                       (unsigned long long)btrfs_ino(page->mapping->host),
                        (unsigned long long)start, csum,
                        (unsigned long long)private);
-        }
         memset(kaddr + offset, 1, end - start + 1);
         flush_dcache_page(page);
         kunmap_atomic(kaddr, KM_USER0);
@@ -2161,8 +2239,6 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
                         insert = 1;
 #endif
                 insert = 1;
-        } else {
-                WARN_ON(!BTRFS_I(inode)->orphan_meta_reserved);
         }
 
         if (!BTRFS_I(inode)->orphan_meta_reserved) {
@@ -2182,7 +2258,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
 
         /* insert an orphan item to track this unlinked/truncated file */
         if (insert >= 1) {
-                ret = btrfs_insert_orphan_item(trans, root, inode->i_ino);
+                ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
                 BUG_ON(ret);
         }
 
@@ -2219,7 +2295,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
         spin_unlock(&root->orphan_lock);
 
         if (trans && delete_item) {
-                ret = btrfs_del_orphan_item(trans, root, inode->i_ino);
+                ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
                 BUG_ON(ret);
         }
 
@@ -2233,21 +2309,23 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
  * this cleans up any orphans that may be left on the list from the last use
  * of this root.
  */
-void btrfs_orphan_cleanup(struct btrfs_root *root)
+int btrfs_orphan_cleanup(struct btrfs_root *root)
 {
         struct btrfs_path *path;
         struct extent_buffer *leaf;
-        struct btrfs_item *item;
         struct btrfs_key key, found_key;
         struct btrfs_trans_handle *trans;
         struct inode *inode;
         int ret = 0, nr_unlink = 0, nr_truncate = 0;
 
         if (cmpxchg(&root->orphan_cleanup_state, 0, ORPHAN_CLEANUP_STARTED))
-                return;
+                return 0;
 
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path) {
+                ret = -ENOMEM;
+                goto out;
+        }
         path->reada = -1;
 
         key.objectid = BTRFS_ORPHAN_OBJECTID;
@@ -2256,18 +2334,16 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
-                if (ret < 0) {
-                        printk(KERN_ERR "Error searching slot for orphan: %d"
-                               "\n", ret);
-                        break;
-                }
+                if (ret < 0)
+                        goto out;
 
                 /*
                  * if ret == 0 means we found what we were searching for, which
-                 * is weird, but possible, so only screw with path if we didnt
+                 * is weird, but possible, so only screw with path if we didn't
                  * find the key and see if we have stuff that matches
                  */
                 if (ret > 0) {
+                        ret = 0;
                         if (path->slots[0] == 0)
                                 break;
                         path->slots[0]--;
@@ -2275,7 +2351,6 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
                 /* pull out the item */
                 leaf = path->nodes[0];
-                item = btrfs_item_nr(leaf, path->slots[0]);
                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 
                 /* make sure the item matches what we want */
@@ -2285,7 +2360,7 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                         break;
 
                 /* release the path since we're done with it */
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
 
                 /*
                  * this is where we are basically btrfs_lookup, without the
@@ -2296,7 +2371,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                 found_key.type = BTRFS_INODE_ITEM_KEY;
                 found_key.offset = 0;
                 inode = btrfs_iget(root->fs_info->sb, &found_key, root, NULL);
-                BUG_ON(IS_ERR(inode));
+                if (IS_ERR(inode)) {
+                        ret = PTR_ERR(inode);
+                        goto out;
+                }
 
                 /*
                  * add this inode to the orphan list so btrfs_orphan_del does
@@ -2314,6 +2392,10 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                  */
                 if (is_bad_inode(inode)) {
                         trans = btrfs_start_transaction(root, 0);
+                        if (IS_ERR(trans)) {
+                                ret = PTR_ERR(trans);
+                                goto out;
+                        }
                         btrfs_orphan_del(trans, inode);
                         btrfs_end_transaction(trans, root);
                         iput(inode);
@@ -2322,17 +2404,22 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
 
                 /* if we have links, this was a truncate, lets do that */
                 if (inode->i_nlink) {
+                        if (!S_ISREG(inode->i_mode)) {
+                                WARN_ON(1);
+                                iput(inode);
+                                continue;
+                        }
                         nr_truncate++;
-                        btrfs_truncate(inode);
+                        ret = btrfs_truncate(inode);
                 } else {
                         nr_unlink++;
                 }
 
                 /* this will do delete_inode and everything for us */
                 iput(inode);
+                if (ret)
+                        goto out;
         }
-        btrfs_free_path(path);
-
         root->orphan_cleanup_state = ORPHAN_CLEANUP_DONE;
 
         if (root->orphan_block_rsv)
@@ -2340,14 +2427,21 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
                                         (u64)-1);
 
         if (root->orphan_block_rsv || root->orphan_item_inserted) {
-                trans = btrfs_join_transaction(root, 1);
-                btrfs_end_transaction(trans, root);
+                trans = btrfs_join_transaction(root);
+                if (!IS_ERR(trans))
+                        btrfs_end_transaction(trans, root);
         }
 
         if (nr_unlink)
                 printk(KERN_INFO "btrfs: unlinked %d orphans\n", nr_unlink);
         if (nr_truncate)
                 printk(KERN_INFO "btrfs: truncated %d orphans\n", nr_truncate);
+
+out:
+        if (ret)
+                printk(KERN_CRIT "btrfs: could not do orphan cleanup %d\n", ret);
+        btrfs_free_path(path);
+        return ret;
 }
 
 /*
@@ -2413,12 +2507,17 @@ static void btrfs_read_locked_inode(struct inode *inode)
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_key location;
         int maybe_acls;
-        u64 alloc_group_block;
         u32 rdev;
         int ret;
+        bool filled = false;
+
+        ret = btrfs_fill_inode(inode, &rdev);
+        if (!ret)
+                filled = true;
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
+        path->leave_spinning = 1;
         memcpy(&location, &BTRFS_I(inode)->location, sizeof(location));
 
         ret = btrfs_lookup_inode(NULL, root, path, &location, 0);
@@ -2426,8 +2525,18 @@ static void btrfs_read_locked_inode(struct inode *inode)
                 goto make_bad;
 
         leaf = path->nodes[0];
+
+        if (filled)
+                goto cache_acl;
+
         inode_item = btrfs_item_ptr(leaf, path->slots[0],
                                     struct btrfs_inode_item);
+        if (!leaf->map_token)
+                map_private_extent_buffer(leaf, (unsigned long)inode_item,
+                                          sizeof(struct btrfs_inode_item),
+                                          &leaf->map_token, &leaf->kaddr,
+                                          &leaf->map_start, &leaf->map_len,
+                                          KM_USER1);
 
         inode->i_mode = btrfs_inode_mode(leaf, inode_item);
         inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
@@ -2456,21 +2565,22 @@ static void btrfs_read_locked_inode(struct inode *inode)
 
         BTRFS_I(inode)->index_cnt = (u64)-1;
         BTRFS_I(inode)->flags = btrfs_inode_flags(leaf, inode_item);
-
-        alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
-
+cache_acl:
         /*
          * try to precache a NULL acl entry for files that don't have
          * any xattrs or acls
          */
-        maybe_acls = acls_after_inode_item(leaf, path->slots[0], inode->i_ino);
+        maybe_acls = acls_after_inode_item(leaf, path->slots[0],
+                                           btrfs_ino(inode));
         if (!maybe_acls)
                 cache_no_acl(inode);
 
-        BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
-                                                alloc_group_block, 0);
+        if (leaf->map_token) {
+                unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
+                leaf->map_token = NULL;
+        }
+
         btrfs_free_path(path);
-        inode_item = NULL;
 
         switch (inode->i_mode & S_IFMT) {
         case S_IFREG:
@@ -2514,6 +2624,13 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
                             struct btrfs_inode_item *item,
                             struct inode *inode)
 {
+        if (!leaf->map_token)
+                map_private_extent_buffer(leaf, (unsigned long)item,
+                                          sizeof(struct btrfs_inode_item),
+                                          &leaf->map_token, &leaf->kaddr,
+                                          &leaf->map_start, &leaf->map_len,
+                                          KM_USER1);
+
         btrfs_set_inode_uid(leaf, item, inode->i_uid);
         btrfs_set_inode_gid(leaf, item, inode->i_gid);
         btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
@@ -2541,7 +2658,12 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
         btrfs_set_inode_transid(leaf, item, trans->transid);
         btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
         btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
-        btrfs_set_inode_block_group(leaf, item, BTRFS_I(inode)->block_group);
+        btrfs_set_inode_block_group(leaf, item, 0);
+
+        if (leaf->map_token) {
+                unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
+                leaf->map_token = NULL;
+        }
 }
 
 /*
@@ -2555,11 +2677,28 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
         struct extent_buffer *leaf;
         int ret;
 
+        /*
+         * If the inode is a free space inode, we can deadlock during commit
+         * if we put it into the delayed code.
+         *
+         * The data relocation inode should also be directly updated
+         * without delay
+         */
+        if (!is_free_space_inode(root, inode)
+            && root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID) {
+                ret = btrfs_delayed_update_inode(trans, root, inode);
+                if (!ret)
+                        btrfs_set_inode_last_trans(trans, inode);
+                return ret;
+        }
+
         path = btrfs_alloc_path();
-        BUG_ON(!path);
+        if (!path)
+                return -ENOMEM;
+
         path->leave_spinning = 1;
-        ret = btrfs_lookup_inode(trans, root, path,
-                                 &BTRFS_I(inode)->location, 1);
+        ret = btrfs_lookup_inode(trans, root, path, &BTRFS_I(inode)->location,
+                                 1);
         if (ret) {
                 if (ret > 0)
                         ret = -ENOENT;
@@ -2569,7 +2708,7 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
         btrfs_unlock_up_safe(path, 1);
         leaf = path->nodes[0];
         inode_item = btrfs_item_ptr(leaf, path->slots[0],
-                                  struct btrfs_inode_item);
+                                    struct btrfs_inode_item);
 
         fill_inode_item(trans, leaf, inode_item, inode);
         btrfs_mark_buffer_dirty(leaf);
@@ -2580,16 +2719,15 @@ failed:
         return ret;
 }
 
-
 /*
  * unlink helper that gets used here in inode.c and in the tree logging
  * recovery code.  It remove a link in a directory with a given name, and
  * also drops the back refs in the inode to the directory
  */
-int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
-                       struct btrfs_root *root,
-                       struct inode *dir, struct inode *inode,
-                       const char *name, int name_len)
+static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root,
+                                struct inode *dir, struct inode *inode,
+                                const char *name, int name_len)
 {
         struct btrfs_path *path;
         int ret = 0;
@@ -2597,15 +2735,17 @@ int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         struct btrfs_dir_item *di;
         struct btrfs_key key;
         u64 index;
+        u64 ino = btrfs_ino(inode);
+        u64 dir_ino = btrfs_ino(dir);
 
         path = btrfs_alloc_path();
         if (!path) {
                 ret = -ENOMEM;
-                goto err;
+                goto out;
         }
 
         path->leave_spinning = 1;
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                     name, name_len, -1);
         if (IS_ERR(di)) {
                 ret = PTR_ERR(di);
@@ -2620,38 +2760,29 @@ int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         ret = btrfs_delete_one_dir_name(trans, root, path, di);
         if (ret)
                 goto err;
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
-        ret = btrfs_del_inode_ref(trans, root, name, name_len,
-                                  inode->i_ino,
-                                  dir->i_ino, &index);
+        ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
+                                  dir_ino, &index);
         if (ret) {
                 printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
-                       "inode %lu parent %lu\n", name_len, name,
-                       inode->i_ino, dir->i_ino);
+                       "inode %llu parent %llu\n", name_len, name,
+                       (unsigned long long)ino, (unsigned long long)dir_ino);
                 goto err;
         }
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
-                                         index, name, name_len, -1);
-        if (IS_ERR(di)) {
-                ret = PTR_ERR(di);
-                goto err;
-        }
-        if (!di) {
-                ret = -ENOENT;
+        ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
+        if (ret)
                 goto err;
-        }
-        ret = btrfs_delete_one_dir_name(trans, root, path, di);
-        btrfs_release_path(root, path);
 
         ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
-                                         inode, dir->i_ino);
+                                         inode, dir_ino);
         BUG_ON(ret != 0 && ret != -ENOENT);
 
         ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
                                            dir, index);
-        BUG_ON(ret);
+        if (ret == -ENOENT)
+                ret = 0;
 err:
         btrfs_free_path(path);
         if (ret)
@@ -2660,22 +2791,36 @@ err:
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
         inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
         btrfs_update_inode(trans, root, dir);
-        btrfs_drop_nlink(inode);
-        ret = btrfs_update_inode(trans, root, inode);
 out:
         return ret;
 }
 
+int btrfs_unlink_inode(struct btrfs_trans_handle *trans,
+                       struct btrfs_root *root,
+                       struct inode *dir, struct inode *inode,
+                       const char *name, int name_len)
+{
+        int ret;
+        ret = __btrfs_unlink_inode(trans, root, dir, inode, name, name_len);
+        if (!ret) {
+                btrfs_drop_nlink(inode);
+                ret = btrfs_update_inode(trans, root, inode);
+        }
+        return ret;
+}
+                
+
 /* helper to check if there is any shared block in the path */
 static int check_path_shared(struct btrfs_root *root,
                              struct btrfs_path *path)
 {
         struct extent_buffer *eb;
         int level;
-        int ret;
         u64 refs = 1;
 
         for (level = 0; level < BTRFS_MAX_LEVEL; level++) {
+                int ret;
+
                 if (!path->nodes[level])
                         break;
                 eb = path->nodes[level];
@@ -2709,12 +2854,14 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         int check_link = 1;
         int err = -ENOSPC;
         int ret;
+        u64 ino = btrfs_ino(inode);
+        u64 dir_ino = btrfs_ino(dir);
 
         trans = btrfs_start_transaction(root, 10);
         if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
                 return trans;
 
-        if (inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
+        if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
                 return ERR_PTR(-ENOSPC);
 
         /* check if there is someone else holds reference */
@@ -2755,7 +2902,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         } else {
                 check_link = 0;
         }
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         ret = btrfs_lookup_inode(trans, root, path,
                                 &BTRFS_I(inode)->location, 0);
@@ -2769,11 +2916,11 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         } else {
                 check_link = 0;
         }
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         if (ret == 0 && S_ISREG(inode->i_mode)) {
                 ret = btrfs_lookup_file_extent(trans, root, path,
-                                               inode->i_ino, (u64)-1, 0);
+                                               ino, (u64)-1, 0);
                 if (ret < 0) {
                         err = ret;
                         goto out;
@@ -2781,7 +2928,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
                 BUG_ON(ret == 0);
                 if (check_path_shared(root, path))
                         goto out;
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
         }
 
         if (!check_link) {
@@ -2789,7 +2936,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
                 goto out;
         }
 
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                 dentry->d_name.name, dentry->d_name.len, 0);
         if (IS_ERR(di)) {
                 err = PTR_ERR(di);
@@ -2802,11 +2949,11 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
                 err = 0;
                 goto out;
         }
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         ref = btrfs_lookup_inode_ref(trans, root, path,
                                 dentry->d_name.name, dentry->d_name.len,
-                                inode->i_ino, dir->i_ino, 0);
+                                ino, dir_ino, 0);
         if (IS_ERR(ref)) {
                 err = PTR_ERR(ref);
                 goto out;
@@ -2815,9 +2962,17 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         if (check_path_shared(root, path))
                 goto out;
         index = btrfs_inode_ref_index(path->nodes[0], ref);
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino, index,
+        /*
+         * This is a commit root search, if we can lookup inode item and other
+         * relative items in the commit root, it means the transaction of
+         * dir/file creation has been committed, and the dir index item that we
+         * delay to insert has also been inserted into the commit root. So
+         * we needn't worry about the delayed insertion of the dir index item
+         * here.
+         */
+        di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
                                 dentry->d_name.name, dentry->d_name.len, 0);
         if (IS_ERR(di)) {
                 err = PTR_ERR(di);
@@ -2862,8 +3017,6 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_set_trans_block_group(trans, dir);
-
         btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0);
 
         ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode,
@@ -2892,47 +3045,41 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
         struct btrfs_key key;
         u64 index;
         int ret;
+        u64 dir_ino = btrfs_ino(dir);
 
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
 
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                    name, name_len, -1);
-        BUG_ON(!di || IS_ERR(di));
+        BUG_ON(IS_ERR_OR_NULL(di));
 
         leaf = path->nodes[0];
         btrfs_dir_item_key_to_cpu(leaf, di, &key);
         WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
         ret = btrfs_delete_one_dir_name(trans, root, path, di);
         BUG_ON(ret);
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
 
         ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
                                  objectid, root->root_key.objectid,
-                                 dir->i_ino, &index, name, name_len);
+                                 dir_ino, &index, name, name_len);
         if (ret < 0) {
                 BUG_ON(ret != -ENOENT);
-                di = btrfs_search_dir_index_item(root, path, dir->i_ino,
+                di = btrfs_search_dir_index_item(root, path, dir_ino,
                                                  name, name_len);
-                BUG_ON(!di || IS_ERR(di));
+                BUG_ON(IS_ERR_OR_NULL(di));
 
                 leaf = path->nodes[0];
                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
-                btrfs_release_path(root, path);
+                btrfs_release_path(path);
                 index = key.offset;
         }
+        btrfs_release_path(path);
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
-                                         index, name, name_len, -1);
-        BUG_ON(!di || IS_ERR(di));
-
-        leaf = path->nodes[0];
-        btrfs_dir_item_key_to_cpu(leaf, di, &key);
-        WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid);
-        ret = btrfs_delete_one_dir_name(trans, root, path, di);
+        ret = btrfs_delete_delayed_dir_index(trans, root, dir, index);
         BUG_ON(ret);
-        btrfs_release_path(root, path);
 
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
@@ -2952,16 +3099,14 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         unsigned long nr = 0;
 
         if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
-            inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+            btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
                 return -ENOTEMPTY;
 
         trans = __unlink_start_trans(dir, dentry);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_set_trans_block_group(trans, dir);
-
-        if (unlikely(inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
+        if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
                 err = btrfs_unlink_subvol(trans, root, dir,
                                           BTRFS_I(inode)->location.objectid,
                                           dentry->d_name.name,
@@ -2986,178 +3131,6 @@ out:
         return err;
 }
 
-#if 0
-/*
- * when truncating bytes in a file, it is possible to avoid reading
- * the leaves that contain only checksum items.  This can be the
- * majority of the IO required to delete a large file, but it must
- * be done carefully.
- *
- * The keys in the level just above the leaves are checked to make sure
- * the lowest key in a given leaf is a csum key, and starts at an offset
- * after the new  size.
- *
- * Then the key for the next leaf is checked to make sure it also has
- * a checksum item for the same file.  If it does, we know our target leaf
- * contains only checksum items, and it can be safely freed without reading
- * it.
- *
- * This is just an optimization targeted at large files.  It may do
- * nothing.  It will return 0 unless things went badly.
- */
-static noinline int drop_csum_leaves(struct btrfs_trans_handle *trans,
-                                     struct btrfs_root *root,
-                                     struct btrfs_path *path,
-                                     struct inode *inode, u64 new_size)
-{
-        struct btrfs_key key;
-        int ret;
-        int nritems;
-        struct btrfs_key found_key;
-        struct btrfs_key other_key;
-        struct btrfs_leaf_ref *ref;
-        u64 leaf_gen;
-        u64 leaf_start;
-
-        path->lowest_level = 1;
-        key.objectid = inode->i_ino;
-        key.type = BTRFS_CSUM_ITEM_KEY;
-        key.offset = new_size;
-again:
-        ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
-        if (ret < 0)
-                goto out;
-
-        if (path->nodes[1] == NULL) {
-                ret = 0;
-                goto out;
-        }
-        ret = 0;
-        btrfs_node_key_to_cpu(path->nodes[1], &found_key, path->slots[1]);
-        nritems = btrfs_header_nritems(path->nodes[1]);
-
-        if (!nritems)
-                goto out;
-
-        if (path->slots[1] >= nritems)
-                goto next_node;
-
-        /* did we find a key greater than anything we want to delete? */
-        if (found_key.objectid > inode->i_ino ||
-           (found_key.objectid == inode->i_ino && found_key.type > key.type))
-                goto out;
-
-        /* we check the next key in the node to make sure the leave contains
-         * only checksum items.  This comparison doesn't work if our
-         * leaf is the last one in the node
-         */
-        if (path->slots[1] + 1 >= nritems) {
-next_node:
-                /* search forward from the last key in the node, this
-                 * will bring us into the next node in the tree
-                 */
-                btrfs_node_key_to_cpu(path->nodes[1], &found_key, nritems - 1);
-
-                /* unlikely, but we inc below, so check to be safe */
-                if (found_key.offset == (u64)-1)
-                        goto out;
-
-                /* search_forward needs a path with locks held, do the
-                 * search again for the original key.  It is possible
-                 * this will race with a balance and return a path that
-                 * we could modify, but this drop is just an optimization
-                 * and is allowed to miss some leaves.
-                 */
-                btrfs_release_path(root, path);
-                found_key.offset++;
-
-                /* setup a max key for search_forward */
-                other_key.offset = (u64)-1;
-                other_key.type = key.type;
-                other_key.objectid = key.objectid;
-
-                path->keep_locks = 1;
-                ret = btrfs_search_forward(root, &found_key, &other_key,
-                                           path, 0, 0);
-                path->keep_locks = 0;
-                if (ret || found_key.objectid != key.objectid ||
-                    found_key.type != key.type) {
-                        ret = 0;
-                        goto out;
-                }
-
-                key.offset = found_key.offset;
-                btrfs_release_path(root, path);
-                cond_resched();
-                goto again;
-        }
-
-        /* we know there's one more slot after us in the tree,
-         * read that key so we can verify it is also a checksum item
-         */
-        btrfs_node_key_to_cpu(path->nodes[1], &other_key, path->slots[1] + 1);
-
-        if (found_key.objectid < inode->i_ino)
-                goto next_key;
-
-        if (found_key.type != key.type || found_key.offset < new_size)
-                goto next_key;
-
-        /*
-         * if the key for the next leaf isn't a csum key from this objectid,
-         * we can't be sure there aren't good items inside this leaf.
-         * Bail out
-         */
-        if (other_key.objectid != inode->i_ino || other_key.type != key.type)
-                goto out;
-
-        leaf_start = btrfs_node_blockptr(path->nodes[1], path->slots[1]);
-        leaf_gen = btrfs_node_ptr_generation(path->nodes[1], path->slots[1]);
-        /*
-         * it is safe to delete this leaf, it contains only
-         * csum items from this inode at an offset >= new_size
-         */
-        ret = btrfs_del_leaf(trans, root, path, leaf_start);
-        BUG_ON(ret);
-
-        if (root->ref_cows && leaf_gen < trans->transid) {
-                ref = btrfs_alloc_leaf_ref(root, 0);
-                if (ref) {
-                        ref->root_gen = root->root_key.offset;
-                        ref->bytenr = leaf_start;
-                        ref->owner = 0;
-                        ref->generation = leaf_gen;
-                        ref->nritems = 0;
-
-                        btrfs_sort_leaf_ref(ref);
-
-                        ret = btrfs_add_leaf_ref(root, ref, 0);
-                        WARN_ON(ret);
-                        btrfs_free_leaf_ref(root, ref);
-                } else {
-                        WARN_ON(1);
-                }
-        }
-next_key:
-        btrfs_release_path(root, path);
-
-        if (other_key.objectid == inode->i_ino &&
-            other_key.type == key.type && other_key.offset > key.offset) {
-                key.offset = other_key.offset;
-                cond_resched();
-                goto again;
-        }
-        ret = 0;
-out:
-        /* fixup any changes we've made to the path */
-        path->lowest_level = 0;
-        path->keep_locks = 0;
-        btrfs_release_path(root, path);
-        return ret;
-}
-
-#endif
-
 /*
  * this can truncate away extent items, csum items and directory items.
  * It starts at a high offset and removes keys until it can't find
@@ -3193,17 +3166,27 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         int encoding;
         int ret;
         int err = 0;
+        u64 ino = btrfs_ino(inode);
 
         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
 
-        if (root->ref_cows)
+        if (root->ref_cows || root == root->fs_info->tree_root)
                 btrfs_drop_extent_cache(inode, new_size & (~mask), (u64)-1, 0);
 
+        /*
+         * This function is also used to drop the items in the log tree before
+         * we relog the inode, so if root != BTRFS_I(inode)->root, it means
+         * it is used to drop the loged items. So we shouldn't kill the delayed
+         * items.
+         */
+        if (min_type == 0 && root == BTRFS_I(inode)->root)
+                btrfs_kill_delayed_inode_items(inode);
+
         path = btrfs_alloc_path();
         BUG_ON(!path);
         path->reada = -1;
 
-        key.objectid = inode->i_ino;
+        key.objectid = ino;
         key.offset = (u64)-1;
         key.type = (u8)-1;
 
@@ -3231,7 +3214,7 @@ search_again:
                 found_type = btrfs_key_type(&found_key);
                 encoding = 0;
 
-                if (found_key.objectid != inode->i_ino)
+                if (found_key.objectid != ino)
                         break;
 
                 if (found_type < min_type)
@@ -3321,7 +3304,6 @@ search_again:
                                     btrfs_file_extent_calc_inline_size(size);
                                 ret = btrfs_truncate_item(trans, root, path,
                                                           size, 1);
-                                BUG_ON(ret);
                         } else if (root->ref_cows) {
                                 inode_sub_bytes(inode, item_end + 1 -
                                                 found_key.offset);
@@ -3344,12 +3326,13 @@ delete:
                 } else {
                         break;
                 }
-                if (found_extent && root->ref_cows) {
+                if (found_extent && (root->ref_cows ||
+                                     root == root->fs_info->tree_root)) {
                         btrfs_set_path_blocking(path);
                         ret = btrfs_free_extent(trans, root, extent_start,
                                                 extent_num_bytes, 0,
                                                 btrfs_header_owner(leaf),
-                                                inode->i_ino, extent_offset);
+                                                ino, extent_offset);
                         BUG_ON(ret);
                 }
 
@@ -3358,7 +3341,9 @@ delete:
 
                 if (path->slots[0] == 0 ||
                     path->slots[0] != pending_del_slot) {
-                        if (root->ref_cows) {
+                        if (root->ref_cows &&
+                            BTRFS_I(inode)->location.objectid !=
+                                                BTRFS_FREE_INO_OBJECTID) {
                                 err = -EAGAIN;
                                 goto out;
                         }
@@ -3369,7 +3354,7 @@ delete:
                                 BUG_ON(ret);
                                 pending_del_nr = 0;
                         }
-                        btrfs_release_path(root, path);
+                        btrfs_release_path(path);
                         goto search_again;
                 } else {
                         path->slots[0]--;
@@ -3485,7 +3470,13 @@ out:
         return ret;
 }
 
-int btrfs_cont_expand(struct inode *inode, loff_t size)
+/*
+ * This function puts in dummy file extents for the area we're creating a hole
+ * for.  So if we are truncating this file to a larger size we need to insert
+ * these file extents so that btrfs_get_extent will return a EXTENT_MAP_HOLE for
+ * the range between oldsize and size
+ */
+int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -3493,7 +3484,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
         struct extent_map *em = NULL;
         struct extent_state *cached_state = NULL;
         u64 mask = root->sectorsize - 1;
-        u64 hole_start = (inode->i_size + mask) & ~mask;
+        u64 hole_start = (oldsize + mask) & ~mask;
         u64 block_end = (size + mask) & ~mask;
         u64 last_byte;
         u64 cur_offset;
@@ -3521,7 +3512,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
         while (1) {
                 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
                                 block_end - cur_offset, 0);
-                BUG_ON(IS_ERR(em) || !em);
+                BUG_ON(IS_ERR_OR_NULL(em));
                 last_byte = min(extent_map_end(em), block_end);
                 last_byte = (last_byte + mask) & ~mask;
                 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
@@ -3533,18 +3524,19 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
                                 err = PTR_ERR(trans);
                                 break;
                         }
-                        btrfs_set_trans_block_group(trans, inode);
 
                         err = btrfs_drop_extents(trans, inode, cur_offset,
                                                  cur_offset + hole_size,
                                                  &hint_byte, 1);
-                        BUG_ON(err);
+                        if (err)
+                                break;
 
                         err = btrfs_insert_file_extent(trans, root,
-                                        inode->i_ino, cur_offset, 0,
+                                        btrfs_ino(inode), cur_offset, 0,
                                         0, hole_size, 0, hole_size,
                                         0, 0, 0);
-                        BUG_ON(err);
+                        if (err)
+                                break;
 
                         btrfs_drop_extent_cache(inode, hole_start,
                                         last_byte - 1, 0);
@@ -3564,94 +3556,58 @@ int btrfs_cont_expand(struct inode *inode, loff_t size)
         return err;
 }
 
-static int btrfs_setattr_size(struct inode *inode, struct iattr *attr)
+static int btrfs_setsize(struct inode *inode, loff_t newsize)
 {
-        struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
-        unsigned long nr;
+        loff_t oldsize = i_size_read(inode);
         int ret;
 
-        if (attr->ia_size == inode->i_size)
+        if (newsize == oldsize)
                 return 0;
 
-        if (attr->ia_size > inode->i_size) {
-                unsigned long limit;
-                limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
-                if (attr->ia_size > inode->i_sb->s_maxbytes)
-                        return -EFBIG;
-                if (limit != RLIM_INFINITY && attr->ia_size > limit) {
-                        send_sig(SIGXFSZ, current, 0);
-                        return -EFBIG;
-                }
-        }
-
-        trans = btrfs_start_transaction(root, 5);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
-
-        btrfs_set_trans_block_group(trans, inode);
-
-        ret = btrfs_orphan_add(trans, inode);
-        BUG_ON(ret);
-
-        nr = trans->blocks_used;
-        btrfs_end_transaction(trans, root);
-        btrfs_btree_balance_dirty(root, nr);
-
-        if (attr->ia_size > inode->i_size) {
-                ret = btrfs_cont_expand(inode, attr->ia_size);
+        if (newsize > oldsize) {
+                i_size_write(inode, newsize);
+                btrfs_ordered_update_i_size(inode, i_size_read(inode), NULL);
+                truncate_pagecache(inode, oldsize, newsize);
+                ret = btrfs_cont_expand(inode, oldsize, newsize);
                 if (ret) {
-                        btrfs_truncate(inode);
+                        btrfs_setsize(inode, oldsize);
                         return ret;
                 }
 
-                i_size_write(inode, attr->ia_size);
-                btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
+                mark_inode_dirty(inode);
+        } else {
 
-                trans = btrfs_start_transaction(root, 0);
-                BUG_ON(IS_ERR(trans));
-                btrfs_set_trans_block_group(trans, inode);
-                trans->block_rsv = root->orphan_block_rsv;
-                BUG_ON(!trans->block_rsv);
+                /*
+                 * We're truncating a file that used to have good data down to
+                 * zero. Make sure it gets into the ordered flush list so that
+                 * any new writes get down to disk quickly.
+                 */
+                if (newsize == 0)
+                        BTRFS_I(inode)->ordered_data_close = 1;
 
-                ret = btrfs_update_inode(trans, root, inode);
-                BUG_ON(ret);
-                if (inode->i_nlink > 0) {
-                        ret = btrfs_orphan_del(trans, inode);
-                        BUG_ON(ret);
-                }
-                nr = trans->blocks_used;
-                btrfs_end_transaction(trans, root);
-                btrfs_btree_balance_dirty(root, nr);
-                return 0;
+                /* we don't support swapfiles, so vmtruncate shouldn't fail */
+                truncate_setsize(inode, newsize);
+                ret = btrfs_truncate(inode);
         }
 
-        /*
-         * We're truncating a file that used to have good data down to
-         * zero. Make sure it gets into the ordered flush list so that
-         * any new writes get down to disk quickly.
-         */
-        if (attr->ia_size == 0)
-                BTRFS_I(inode)->ordered_data_close = 1;
-
-        /* we don't support swapfiles, so vmtruncate shouldn't fail */
-        ret = vmtruncate(inode, attr->ia_size);
-        BUG_ON(ret);
-
-        return 0;
+        return ret;
 }
 
 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
 {
         struct inode *inode = dentry->d_inode;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
         int err;
 
+        if (btrfs_root_readonly(root))
+                return -EROFS;
+
         err = inode_change_ok(inode, attr);
         if (err)
                 return err;
 
         if (S_ISREG(inode->i_mode) && (attr->ia_valid & ATTR_SIZE)) {
-                err = btrfs_setattr_size(inode, attr);
+                err = btrfs_setsize(inode, attr->ia_size);
                 if (err)
                         return err;
         }
@@ -3674,8 +3630,11 @@ void btrfs_evict_inode(struct inode *inode)
         unsigned long nr;
         int ret;
 
+        trace_btrfs_inode_evict(inode);
+
         truncate_inode_pages(&inode->i_data, 0);
-        if (inode->i_nlink && btrfs_root_refs(&root->root_item) != 0)
+        if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
+                               is_free_space_inode(root, inode)))
                 goto no_delete;
 
         if (is_bad_inode(inode)) {
@@ -3698,9 +3657,8 @@ void btrfs_evict_inode(struct inode *inode)
         btrfs_i_size_write(inode, 0);
 
         while (1) {
-                trans = btrfs_start_transaction(root, 0);
+                trans = btrfs_join_transaction(root);
                 BUG_ON(IS_ERR(trans));
-                btrfs_set_trans_block_group(trans, inode);
                 trans->block_rsv = root->orphan_block_rsv;
 
                 ret = btrfs_block_rsv_check(trans, root,
@@ -3728,6 +3686,10 @@ void btrfs_evict_inode(struct inode *inode)
                 BUG_ON(ret);
         }
 
+        if (!(root == root->fs_info->tree_root ||
+              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);
@@ -3753,12 +3715,12 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
         path = btrfs_alloc_path();
         BUG_ON(!path);
 
-        di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
+        di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
                                     namelen, 0);
         if (IS_ERR(di))
                 ret = PTR_ERR(di);
 
-        if (!di || IS_ERR(di))
+        if (IS_ERR_OR_NULL(di))
                 goto out_err;
 
         btrfs_dir_item_key_to_cpu(path->nodes[0], di, location);
@@ -3806,7 +3768,7 @@ static int fixup_tree_root_location(struct btrfs_root *root,
 
         leaf = path->nodes[0];
         ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
-        if (btrfs_root_ref_dirid(leaf, ref) != dir->i_ino ||
+        if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
             btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
                 goto out;
 
@@ -3816,7 +3778,7 @@ static int fixup_tree_root_location(struct btrfs_root *root,
         if (ret)
                 goto out;
 
-        btrfs_release_path(root->fs_info->tree_root, path);
+        btrfs_release_path(path);
 
         new_root = btrfs_read_fs_root_no_name(root->fs_info, location);
         if (IS_ERR(new_root)) {
@@ -3845,11 +3807,12 @@ static void inode_tree_add(struct inode *inode)
         struct btrfs_inode *entry;
         struct rb_node **p;
         struct rb_node *parent;
+        u64 ino = btrfs_ino(inode);
 again:
         p = &root->inode_tree.rb_node;
         parent = NULL;
 
-        if (hlist_unhashed(&inode->i_hash))
+        if (inode_unhashed(inode))
                 return;
 
         spin_lock(&root->inode_lock);
@@ -3857,9 +3820,9 @@ again:
                 parent = *p;
                 entry = rb_entry(parent, struct btrfs_inode, rb_node);
 
-                if (inode->i_ino < entry->vfs_inode.i_ino)
+                if (ino < btrfs_ino(&entry->vfs_inode))
                         p = &parent->rb_left;
-                else if (inode->i_ino > entry->vfs_inode.i_ino)
+                else if (ino > btrfs_ino(&entry->vfs_inode))
                         p = &parent->rb_right;
                 else {
                         WARN_ON(!(entry->vfs_inode.i_state &
@@ -3888,7 +3851,14 @@ static void inode_tree_del(struct inode *inode)
         }
         spin_unlock(&root->inode_lock);
 
-        if (empty && btrfs_root_refs(&root->root_item) == 0) {
+        /*
+         * Free space cache has inodes in the tree root, but the tree root has a
+         * root_refs of 0, so this could end up dropping the tree root as a
+         * snapshot, so we need the extra !root->fs_info->tree_root check to
+         * make sure we don't drop it.
+         */
+        if (empty && btrfs_root_refs(&root->root_item) == 0 &&
+            root != root->fs_info->tree_root) {
                 synchronize_srcu(&root->fs_info->subvol_srcu);
                 spin_lock(&root->inode_lock);
                 empty = RB_EMPTY_ROOT(&root->inode_tree);
@@ -3916,9 +3886,9 @@ again:
                 prev = node;
                 entry = rb_entry(node, struct btrfs_inode, rb_node);
 
-                if (objectid < entry->vfs_inode.i_ino)
+                if (objectid < btrfs_ino(&entry->vfs_inode))
                         node = node->rb_left;
-                else if (objectid > entry->vfs_inode.i_ino)
+                else if (objectid > btrfs_ino(&entry->vfs_inode))
                         node = node->rb_right;
                 else
                         break;
@@ -3926,7 +3896,7 @@ again:
         if (!node) {
                 while (prev) {
                         entry = rb_entry(prev, struct btrfs_inode, rb_node);
-                        if (objectid <= entry->vfs_inode.i_ino) {
+                        if (objectid <= btrfs_ino(&entry->vfs_inode)) {
                                 node = prev;
                                 break;
                         }
@@ -3935,7 +3905,7 @@ again:
         }
         while (node) {
                 entry = rb_entry(node, struct btrfs_inode, rb_node);
-                objectid = entry->vfs_inode.i_ino + 1;
+                objectid = btrfs_ino(&entry->vfs_inode) + 1;
                 inode = igrab(&entry->vfs_inode);
                 if (inode) {
                         spin_unlock(&root->inode_lock);
@@ -3973,7 +3943,7 @@ static int btrfs_init_locked_inode(struct inode *inode, void *p)
 static int btrfs_find_actor(struct inode *inode, void *opaque)
 {
         struct btrfs_iget_args *args = opaque;
-        return args->ino == inode->i_ino &&
+        return args->ino == btrfs_ino(inode) &&
                 args->root == BTRFS_I(inode)->root;
 }
 
@@ -4008,7 +3978,6 @@ struct inode *btrfs_iget(struct super_block *s, struct btrfs_key *location,
                 BTRFS_I(inode)->root = root;
                 memcpy(&BTRFS_I(inode)->location, location, sizeof(*location));
                 btrfs_read_locked_inode(inode);
-
                 inode_tree_add(inode);
                 unlock_new_inode(inode);
                 if (new)
@@ -4049,8 +4018,6 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
         int index;
         int ret;
 
-        dentry->d_op = &btrfs_dentry_operations;
-
         if (dentry->d_name.len > BTRFS_NAME_LEN)
                 return ERR_PTR(-ENAMETOOLONG);
 
@@ -4082,17 +4049,19 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
         }
         srcu_read_unlock(&root->fs_info->subvol_srcu, index);
 
-        if (root != sub_root) {
+        if (!IS_ERR(inode) && root != sub_root) {
                 down_read(&root->fs_info->cleanup_work_sem);
                 if (!(inode->i_sb->s_flags & MS_RDONLY))
-                        btrfs_orphan_cleanup(sub_root);
+                        ret = btrfs_orphan_cleanup(sub_root);
                 up_read(&root->fs_info->cleanup_work_sem);
+                if (ret)
+                        inode = ERR_PTR(ret);
         }
 
         return inode;
 }
 
-static int btrfs_dentry_delete(struct dentry *dentry)
+static int btrfs_dentry_delete(const struct dentry *dentry)
 {
         struct btrfs_root *root;
 
@@ -4119,7 +4088,7 @@ static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
         return d_splice_alias(inode, dentry);
 }
 
-static unsigned char btrfs_filetype_table[] = {
+unsigned char btrfs_filetype_table[] = {
         DT_UNKNOWN, DT_REG, DT_DIR, DT_CHR, DT_BLK, DT_FIFO, DT_SOCK, DT_LNK
 };
 
@@ -4133,11 +4102,11 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
         struct btrfs_key key;
         struct btrfs_key found_key;
         struct btrfs_path *path;
+        struct list_head ins_list;
+        struct list_head del_list;
         int ret;
-        u32 nritems;
         struct extent_buffer *leaf;
         int slot;
-        int advance;
         unsigned char d_type;
         int over = 0;
         u32 di_cur;
@@ -4147,6 +4116,7 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
         char tmp_name[32];
         char *name_ptr;
         int name_len;
+        int is_curr = 0;        /* filp->f_pos points to the current index? */
 
         /* FIXME, use a real flag for deciding about the key type */
         if (root->fs_info->tree_root == root)
@@ -4154,9 +4124,7 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
 
         /* special case for "." */
         if (filp->f_pos == 0) {
-                over = filldir(dirent, ".", 1,
-                               1, inode->i_ino,
-                               DT_DIR);
+                over = filldir(dirent, ".", 1, 1, btrfs_ino(inode), DT_DIR);
                 if (over)
                         return 0;
                 filp->f_pos = 1;
@@ -4171,36 +4139,37 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
                 filp->f_pos = 2;
         }
         path = btrfs_alloc_path();
-        path->reada = 2;
+        if (!path)
+                return -ENOMEM;
+
+        path->reada = 1;
+
+        if (key_type == BTRFS_DIR_INDEX_KEY) {
+                INIT_LIST_HEAD(&ins_list);
+                INIT_LIST_HEAD(&del_list);
+                btrfs_get_delayed_items(inode, &ins_list, &del_list);
+        }
 
         btrfs_set_key_type(&key, key_type);
         key.offset = filp->f_pos;
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
 
         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
         if (ret < 0)
                 goto err;
-        advance = 0;
 
         while (1) {
                 leaf = path->nodes[0];
-                nritems = btrfs_header_nritems(leaf);
                 slot = path->slots[0];
-                if (advance || slot >= nritems) {
-                        if (slot >= nritems - 1) {
-                                ret = btrfs_next_leaf(root, path);
-                                if (ret)
-                                        break;
-                                leaf = path->nodes[0];
-                                nritems = btrfs_header_nritems(leaf);
-                                slot = path->slots[0];
-                        } else {
-                                slot++;
-                                path->slots[0]++;
-                        }
+                if (slot >= btrfs_header_nritems(leaf)) {
+                        ret = btrfs_next_leaf(root, path);
+                        if (ret < 0)
+                                goto err;
+                        else if (ret > 0)
+                                break;
+                        continue;
                 }
 
-                advance = 1;
                 item = btrfs_item_nr(leaf, slot);
                 btrfs_item_key_to_cpu(leaf, &found_key, slot);
 
@@ -4209,9 +4178,14 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
                 if (btrfs_key_type(&found_key) != key_type)
                         break;
                 if (found_key.offset < filp->f_pos)
-                        continue;
+                        goto next;
+                if (key_type == BTRFS_DIR_INDEX_KEY &&
+                    btrfs_should_delete_dir_index(&del_list,
+                                                  found_key.offset))
+                        goto next;
 
                 filp->f_pos = found_key.offset;
+                is_curr = 1;
 
                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
                 di_cur = 0;
@@ -4220,6 +4194,9 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
                 while (di_cur < di_total) {
                         struct btrfs_key location;
 
+                        if (verify_dir_item(root, leaf, di))
+                                break;
+
                         name_len = btrfs_dir_name_len(leaf, di);
                         if (name_len <= sizeof(tmp_name)) {
                                 name_ptr = tmp_name;
@@ -4259,6 +4236,17 @@ skip:
                         di_cur += di_len;
                         di = (struct btrfs_dir_item *)((char *)di + di_len);
                 }
+next:
+                path->slots[0]++;
+        }
+
+        if (key_type == BTRFS_DIR_INDEX_KEY) {
+                if (is_curr)
+                        filp->f_pos++;
+                ret = btrfs_readdir_delayed_dir_index(filp, dirent, filldir,
+                                                      &ins_list);
+                if (ret)
+                        goto nopos;
         }
 
         /* Reached end of directory/root. Bump pos past the last item. */
@@ -4273,6 +4261,8 @@ skip:
 nopos:
         ret = 0;
 err:
+        if (key_type == BTRFS_DIR_INDEX_KEY)
+                btrfs_put_delayed_items(&ins_list, &del_list);
         btrfs_free_path(path);
         return ret;
 }
@@ -4282,14 +4272,25 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         int ret = 0;
+        bool nolock = false;
 
         if (BTRFS_I(inode)->dummy_inode)
                 return 0;
 
+        if (btrfs_fs_closing(root->fs_info) && is_free_space_inode(root, inode))
+                nolock = true;
+
         if (wbc->sync_mode == WB_SYNC_ALL) {
-                trans = btrfs_join_transaction(root, 1);
-                btrfs_set_trans_block_group(trans, inode);
-                ret = btrfs_commit_transaction(trans, root);
+                if (nolock)
+                        trans = btrfs_join_transaction_nolock(root);
+                else
+                        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);
         }
         return ret;
 }
@@ -4300,7 +4301,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
  * FIXME, needs more benchmarking...there are no reasons other than performance
  * to keep or drop this code.
  */
-void btrfs_dirty_inode(struct inode *inode)
+void btrfs_dirty_inode(struct inode *inode, int flags)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
@@ -4309,8 +4310,8 @@ void btrfs_dirty_inode(struct inode *inode)
         if (BTRFS_I(inode)->dummy_inode)
                 return;
 
-        trans = btrfs_join_transaction(root, 1);
-        btrfs_set_trans_block_group(trans, inode);
+        trans = btrfs_join_transaction(root);
+        BUG_ON(IS_ERR(trans));
 
         ret = btrfs_update_inode(trans, root, inode);
         if (ret && ret == -ENOSPC) {
@@ -4318,25 +4319,24 @@ void btrfs_dirty_inode(struct inode *inode)
                 btrfs_end_transaction(trans, root);
                 trans = btrfs_start_transaction(root, 1);
                 if (IS_ERR(trans)) {
-                        if (printk_ratelimit()) {
-                                printk(KERN_ERR "btrfs: fail to "
-                                       "dirty  inode %lu error %ld\n",
-                                       inode->i_ino, PTR_ERR(trans));
-                        }
+                        printk_ratelimited(KERN_ERR "btrfs: fail to "
+                                       "dirty  inode %llu error %ld\n",
+                                       (unsigned long long)btrfs_ino(inode),
+                                       PTR_ERR(trans));
                         return;
                 }
-                btrfs_set_trans_block_group(trans, inode);
 
                 ret = btrfs_update_inode(trans, root, inode);
                 if (ret) {
-                        if (printk_ratelimit()) {
-                                printk(KERN_ERR "btrfs: fail to "
-                                       "dirty  inode %lu error %d\n",
-                                       inode->i_ino, ret);
-                        }
+                        printk_ratelimited(KERN_ERR "btrfs: fail to "
+                                       "dirty  inode %llu error %d\n",
+                                       (unsigned long long)btrfs_ino(inode),
+                                       ret);
                 }
         }
         btrfs_end_transaction(trans, root);
+        if (BTRFS_I(inode)->delayed_node)
+                btrfs_balance_delayed_items(root);
 }
 
 /*
@@ -4352,7 +4352,7 @@ static int btrfs_set_inode_index_count(struct inode *inode)
         struct extent_buffer *leaf;
         int ret;
 
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
         key.offset = (u64)-1;
 
@@ -4384,7 +4384,7 @@ static int btrfs_set_inode_index_count(struct inode *inode)
         leaf = path->nodes[0];
         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 
-        if (found_key.objectid != inode->i_ino ||
+        if (found_key.objectid != btrfs_ino(inode) ||
             btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
                 BTRFS_I(inode)->index_cnt = 2;
                 goto out;
@@ -4405,9 +4405,12 @@ int btrfs_set_inode_index(struct inode *dir, u64 *index)
         int ret = 0;
 
         if (BTRFS_I(dir)->index_cnt == (u64)-1) {
-                ret = btrfs_set_inode_index_count(dir);
-                if (ret)
-                        return ret;
+                ret = btrfs_inode_delayed_dir_index_count(dir);
+                if (ret) {
+                        ret = btrfs_set_inode_index_count(dir);
+                        if (ret)
+                                return ret;
+                }
         }
 
         *index = BTRFS_I(dir)->index_cnt;
@@ -4420,8 +4423,8 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
                                      struct btrfs_root *root,
                                      struct inode *dir,
                                      const char *name, int name_len,
-                                     u64 ref_objectid, u64 objectid,
-                                     u64 alloc_hint, int mode, u64 *index)
+                                     u64 ref_objectid, u64 objectid, int mode,
+                                     u64 *index)
 {
         struct inode *inode;
         struct btrfs_inode_item *inode_item;
@@ -4438,12 +4441,23 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         BUG_ON(!path);
 
         inode = new_inode(root->fs_info->sb);
-        if (!inode)
+        if (!inode) {
+                btrfs_free_path(path);
                 return ERR_PTR(-ENOMEM);
+        }
+
+        /*
+         * we have to initialize this early, so we can reclaim the inode
+         * number if we fail afterwards in this function.
+         */
+        inode->i_ino = objectid;
 
         if (dir) {
+                trace_btrfs_inode_request(dir);
+
                 ret = btrfs_set_inode_index(dir, index);
                 if (ret) {
+                        btrfs_free_path(path);
                         iput(inode);
                         return ERR_PTR(ret);
                 }
@@ -4456,14 +4470,13 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         BTRFS_I(inode)->index_cnt = 2;
         BTRFS_I(inode)->root = root;
         BTRFS_I(inode)->generation = trans->transid;
+        inode->i_generation = BTRFS_I(inode)->generation;
         btrfs_set_inode_space_info(root, inode);
 
         if (mode & S_IFDIR)
                 owner = 0;
         else
                 owner = 1;
-        BTRFS_I(inode)->block_group =
-                        btrfs_find_block_group(root, 0, alloc_hint, owner);
 
         key[0].objectid = objectid;
         btrfs_set_key_type(&key[0], BTRFS_INODE_ITEM_KEY);
@@ -4482,7 +4495,6 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
                 goto fail;
 
         inode_init_owner(inode, dir, mode);
-        inode->i_ino = objectid;
         inode_set_bytes(inode, 0);
         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
         inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
@@ -4509,12 +4521,17 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
         if ((mode & S_IFREG)) {
                 if (btrfs_test_opt(root, NODATASUM))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATASUM;
-                if (btrfs_test_opt(root, NODATACOW))
+                if (btrfs_test_opt(root, NODATACOW) ||
+                    (BTRFS_I(dir)->flags & BTRFS_INODE_NODATACOW))
                         BTRFS_I(inode)->flags |= BTRFS_INODE_NODATACOW;
         }
 
         insert_inode_hash(inode);
         inode_tree_add(inode);
+
+        trace_btrfs_inode_new(inode);
+        btrfs_set_inode_last_trans(trans, inode);
+
         return inode;
 fail:
         if (dir)
@@ -4542,29 +4559,29 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
         int ret = 0;
         struct btrfs_key key;
         struct btrfs_root *root = BTRFS_I(parent_inode)->root;
+        u64 ino = btrfs_ino(inode);
+        u64 parent_ino = btrfs_ino(parent_inode);
 
-        if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
         } else {
-                key.objectid = inode->i_ino;
+                key.objectid = ino;
                 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
                 key.offset = 0;
         }
 
-        if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
                                          key.objectid, root->root_key.objectid,
-                                         parent_inode->i_ino,
-                                         index, name, name_len);
+                                         parent_ino, index, name, name_len);
         } else if (add_backref) {
-                ret = btrfs_insert_inode_ref(trans, root,
-                                             name, name_len, inode->i_ino,
-                                             parent_inode->i_ino, index);
+                ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
+                                             parent_ino, index);
         }
 
         if (ret == 0) {
                 ret = btrfs_insert_dir_item(trans, root, name, name_len,
-                                            parent_inode->i_ino, &key,
+                                            parent_inode, &key,
                                             btrfs_inode_type(inode), index);
                 BUG_ON(ret);
 
@@ -4577,12 +4594,12 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
 }
 
 static int btrfs_add_nondir(struct btrfs_trans_handle *trans,
-                            struct dentry *dentry, struct inode *inode,
-                            int backref, u64 index)
+                            struct inode *dir, struct dentry *dentry,
+                            struct inode *inode, int backref, u64 index)
 {
-        int err = btrfs_add_link(trans, dentry->d_parent->d_inode,
-                                 inode, dentry->d_name.name,
-                                 dentry->d_name.len, backref, index);
+        int err = btrfs_add_link(trans, dir, inode,
+                                 dentry->d_name.name, dentry->d_name.len,
+                                 backref, index);
         if (!err) {
                 d_instantiate(dentry, inode);
                 return 0;
@@ -4607,10 +4624,6 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
         if (!new_valid_dev(rdev))
                 return -EINVAL;
 
-        err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
-        if (err)
-                return err;
-
         /*
          * 2 for inode item and ref
          * 2 for dir items
@@ -4620,24 +4633,25 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_set_trans_block_group(trans, dir);
+        err = btrfs_find_free_ino(root, &objectid);
+        if (err)
+                goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len,
-                                dentry->d_parent->d_inode->i_ino, objectid,
-                                BTRFS_I(dir)->block_group, mode, &index);
-        err = PTR_ERR(inode);
-        if (IS_ERR(inode))
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
+                                mode, &index);
+        if (IS_ERR(inode)) {
+                err = PTR_ERR(inode);
                 goto out_unlock;
+        }
 
-        err = btrfs_init_inode_security(trans, inode, dir);
+        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
         if (err) {
                 drop_inode = 1;
                 goto out_unlock;
         }
 
-        btrfs_set_trans_block_group(trans, inode);
-        err = btrfs_add_nondir(trans, dentry, inode, 0, index);
+        err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
         if (err)
                 drop_inode = 1;
         else {
@@ -4645,8 +4659,6 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
                 init_special_inode(inode, inode->i_mode, rdev);
                 btrfs_update_inode(trans, root, inode);
         }
-        btrfs_update_inode_block_group(trans, inode);
-        btrfs_update_inode_block_group(trans, dir);
 out_unlock:
         nr = trans->blocks_used;
         btrfs_end_transaction_throttle(trans, root);
@@ -4670,9 +4682,6 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
         u64 objectid;
         u64 index = 0;
 
-        err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
-        if (err)
-                return err;
         /*
          * 2 for inode item and ref
          * 2 for dir items
@@ -4682,25 +4691,25 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_set_trans_block_group(trans, dir);
+        err = btrfs_find_free_ino(root, &objectid);
+        if (err)
+                goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len,
-                                dentry->d_parent->d_inode->i_ino,
-                                objectid, BTRFS_I(dir)->block_group, mode,
-                                &index);
-        err = PTR_ERR(inode);
-        if (IS_ERR(inode))
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
+                                mode, &index);
+        if (IS_ERR(inode)) {
+                err = PTR_ERR(inode);
                 goto out_unlock;
+        }
 
-        err = btrfs_init_inode_security(trans, inode, dir);
+        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
         if (err) {
                 drop_inode = 1;
                 goto out_unlock;
         }
 
-        btrfs_set_trans_block_group(trans, inode);
-        err = btrfs_add_nondir(trans, dentry, inode, 0, index);
+        err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
         if (err)
                 drop_inode = 1;
         else {
@@ -4710,8 +4719,6 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
                 inode->i_op = &btrfs_file_inode_operations;
                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
         }
-        btrfs_update_inode_block_group(trans, inode);
-        btrfs_update_inode_block_group(trans, dir);
 out_unlock:
         nr = trans->blocks_used;
         btrfs_end_transaction_throttle(trans, root);
@@ -4734,41 +4741,42 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         int err;
         int drop_inode = 0;
 
-        if (inode->i_nlink == 0)
-                return -ENOENT;
-
         /* do not allow sys_link's with other subvols of the same device */
         if (root->objectid != BTRFS_I(inode)->root->objectid)
-                return -EPERM;
+                return -EXDEV;
 
-        btrfs_inc_nlink(inode);
+        if (inode->i_nlink == ~0U)
+                return -EMLINK;
 
         err = btrfs_set_inode_index(dir, &index);
         if (err)
                 goto fail;
 
         /*
-         * 1 item for inode ref
+         * 2 items for inode and inode ref
          * 2 items for dir items
+         * 1 item for parent inode
          */
-        trans = btrfs_start_transaction(root, 3);
+        trans = btrfs_start_transaction(root, 5);
         if (IS_ERR(trans)) {
                 err = PTR_ERR(trans);
                 goto fail;
         }
 
-        btrfs_set_trans_block_group(trans, dir);
-        atomic_inc(&inode->i_count);
+        btrfs_inc_nlink(inode);
+        inode->i_ctime = CURRENT_TIME;
+        ihold(inode);
 
-        err = btrfs_add_nondir(trans, dentry, inode, 1, index);
+        err = btrfs_add_nondir(trans, dir, dentry, inode, 1, index);
 
         if (err) {
                 drop_inode = 1;
         } else {
-                btrfs_update_inode_block_group(trans, dir);
+                struct dentry *parent = dget_parent(dentry);
                 err = btrfs_update_inode(trans, root, inode);
                 BUG_ON(err);
-                btrfs_log_new_name(trans, inode, NULL, dentry->d_parent);
+                btrfs_log_new_name(trans, inode, NULL, parent);
+                dput(parent);
         }
 
         nr = trans->blocks_used;
@@ -4793,10 +4801,6 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         u64 index = 0;
         unsigned long nr = 1;
 
-        err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
-        if (err)
-                return err;
-
         /*
          * 2 items for inode and ref
          * 2 items for dir items
@@ -4805,13 +4809,14 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         trans = btrfs_start_transaction(root, 5);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
-        btrfs_set_trans_block_group(trans, dir);
+
+        err = btrfs_find_free_ino(root, &objectid);
+        if (err)
+                goto out_fail;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len,
-                                dentry->d_parent->d_inode->i_ino, objectid,
-                                BTRFS_I(dir)->block_group, S_IFDIR | mode,
-                                &index);
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
+                                S_IFDIR | mode, &index);
         if (IS_ERR(inode)) {
                 err = PTR_ERR(inode);
                 goto out_fail;
@@ -4819,29 +4824,25 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
         drop_on_err = 1;
 
-        err = btrfs_init_inode_security(trans, inode, dir);
+        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
         if (err)
                 goto out_fail;
 
         inode->i_op = &btrfs_dir_inode_operations;
         inode->i_fop = &btrfs_dir_file_operations;
-        btrfs_set_trans_block_group(trans, inode);
 
         btrfs_i_size_write(inode, 0);
         err = btrfs_update_inode(trans, root, inode);
         if (err)
                 goto out_fail;
 
-        err = btrfs_add_link(trans, dentry->d_parent->d_inode,
-                                 inode, dentry->d_name.name,
-                                 dentry->d_name.len, 0, index);
+        err = btrfs_add_link(trans, dir, inode, dentry->d_name.name,
+                             dentry->d_name.len, 0, index);
         if (err)
                 goto out_fail;
 
         d_instantiate(dentry, inode);
         drop_on_err = 0;
-        btrfs_update_inode_block_group(trans, inode);
-        btrfs_update_inode_block_group(trans, dir);
 
 out_fail:
         nr = trans->blocks_used;
@@ -4886,19 +4887,23 @@ static noinline int uncompress_inline(struct btrfs_path *path,
         size_t max_size;
         unsigned long inline_size;
         unsigned long ptr;
+        int compress_type;
 
         WARN_ON(pg_offset != 0);
+        compress_type = btrfs_file_extent_compression(leaf, item);
         max_size = btrfs_file_extent_ram_bytes(leaf, item);
         inline_size = btrfs_file_extent_inline_item_len(leaf,
                                         btrfs_item_nr(leaf, path->slots[0]));
         tmp = kmalloc(inline_size, GFP_NOFS);
+        if (!tmp)
+                return -ENOMEM;
         ptr = btrfs_file_extent_inline_start(item);
 
         read_extent_buffer(leaf, tmp, ptr, inline_size);
 
         max_size = min_t(unsigned long, PAGE_CACHE_SIZE, max_size);
-        ret = btrfs_zlib_decompress(tmp, page, extent_offset,
-                                    inline_size, max_size);
+        ret = btrfs_decompress(compress_type, tmp, page,
+                               extent_offset, inline_size, max_size);
         if (ret) {
                 char *kaddr = kmap_atomic(page, KM_USER0);
                 unsigned long copy_size = min_t(u64,
@@ -4929,7 +4934,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         u64 bytenr;
         u64 extent_start = 0;
         u64 extent_end = 0;
-        u64 objectid = inode->i_ino;
+        u64 objectid = btrfs_ino(inode);
         u32 found_type;
         struct btrfs_path *path = NULL;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -4940,7 +4945,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_trans_handle *trans = NULL;
-        int compressed;
+        int compress_type;
 
 again:
         read_lock(&em_tree->lock);
@@ -4957,7 +4962,7 @@ again:
                 else
                         goto out;
         }
-        em = alloc_extent_map(GFP_NOFS);
+        em = alloc_extent_map();
         if (!em) {
                 err = -ENOMEM;
                 goto out;
@@ -4970,7 +4975,15 @@ again:
 
         if (!path) {
                 path = btrfs_alloc_path();
-                BUG_ON(!path);
+                if (!path) {
+                        err = -ENOMEM;
+                        goto out;
+                }
+                /*
+                 * Chances are we'll be called again, so go ahead and do
+                 * readahead
+                 */
+                path->reada = 1;
         }
 
         ret = btrfs_lookup_file_extent(trans, root, path,
@@ -4999,7 +5012,7 @@ again:
 
         found_type = btrfs_file_extent_type(leaf, item);
         extent_start = found_key.offset;
-        compressed = btrfs_file_extent_compression(leaf, item);
+        compress_type = btrfs_file_extent_compression(leaf, item);
         if (found_type == BTRFS_FILE_EXTENT_REG ||
             found_type == BTRFS_FILE_EXTENT_PREALLOC) {
                 extent_end = extent_start +
@@ -5045,8 +5058,9 @@ again:
                         em->block_start = EXTENT_MAP_HOLE;
                         goto insert;
                 }
-                if (compressed) {
+                if (compress_type != BTRFS_COMPRESS_NONE) {
                         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);
@@ -5080,12 +5094,14 @@ again:
                 em->len = (copy_size + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
                 em->orig_start = EXTENT_MAP_INLINE;
-                if (compressed)
+                if (compress_type) {
                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+                        em->compress_type = compress_type;
+                }
                 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
                 if (create == 0 && !PageUptodate(page)) {
-                        if (btrfs_file_extent_compression(leaf, item) ==
-                            BTRFS_COMPRESS_ZLIB) {
+                        if (btrfs_file_extent_compression(leaf, item) !=
+                            BTRFS_COMPRESS_NONE) {
                                 ret = uncompress_inline(path, inode, page,
                                                         pg_offset,
                                                         extent_offset, item);
@@ -5108,8 +5124,12 @@ again:
                                 kunmap(page);
                                 free_extent_map(em);
                                 em = NULL;
-                                btrfs_release_path(root, path);
-                                trans = btrfs_join_transaction(root, 1);
+
+                                btrfs_release_path(path);
+                                trans = btrfs_join_transaction(root);
+
+                                if (IS_ERR(trans))
+                                        return ERR_CAST(trans);
                                 goto again;
                         }
                         map = kmap(page);
@@ -5119,7 +5139,7 @@ again:
                         btrfs_mark_buffer_dirty(leaf);
                 }
                 set_extent_uptodate(io_tree, em->start,
-                                    extent_map_end(em) - 1, GFP_NOFS);
+                                    extent_map_end(em) - 1, NULL, GFP_NOFS);
                 goto insert;
         } else {
                 printk(KERN_ERR "btrfs unknown found_type %d\n", found_type);
@@ -5132,7 +5152,7 @@ not_found_em:
         em->block_start = EXTENT_MAP_HOLE;
         set_bit(EXTENT_FLAG_VACANCY, &em->flags);
 insert:
-        btrfs_release_path(root, path);
+        btrfs_release_path(path);
         if (em->start > start || extent_map_end(em) <= start) {
                 printk(KERN_ERR "Btrfs: bad extent! em: [%llu %llu] passed "
                        "[%llu %llu]\n", (unsigned long long)em->start,
@@ -5186,6 +5206,9 @@ insert:
         }
         write_unlock(&em_tree->lock);
 out:
+
+        trace_btrfs_get_extent(root, em);
+
         if (path)
                 btrfs_free_path(path);
         if (trans) {
@@ -5200,22 +5223,160 @@ out:
         return em;
 }
 
+struct extent_map *btrfs_get_extent_fiemap(struct inode *inode, struct page *page,
+                                           size_t pg_offset, u64 start, u64 len,
+                                           int create)
+{
+        struct extent_map *em;
+        struct extent_map *hole_em = NULL;
+        u64 range_start = start;
+        u64 end;
+        u64 found;
+        u64 found_end;
+        int err = 0;
+
+        em = btrfs_get_extent(inode, page, pg_offset, start, len, create);
+        if (IS_ERR(em))
+                return em;
+        if (em) {
+                /*
+                 * if our em maps to a hole, there might
+                 * actually be delalloc bytes behind it
+                 */
+                if (em->block_start != EXTENT_MAP_HOLE)
+                        return em;
+                else
+                        hole_em = em;
+        }
+
+        /* check to see if we've wrapped (len == -1 or similar) */
+        end = start + len;
+        if (end < start)
+                end = (u64)-1;
+        else
+                end -= 1;
+
+        em = NULL;
+
+        /* ok, we didn't find anything, lets look for delalloc */
+        found = count_range_bits(&BTRFS_I(inode)->io_tree, &range_start,
+                                 end, len, EXTENT_DELALLOC, 1);
+        found_end = range_start + found;
+        if (found_end < range_start)
+                found_end = (u64)-1;
+
+        /*
+         * we didn't find anything useful, return
+         * the original results from get_extent()
+         */
+        if (range_start > end || found_end <= start) {
+                em = hole_em;
+                hole_em = NULL;
+                goto out;
+        }
+
+        /* adjust the range_start to make sure it doesn't
+         * go backwards from the start they passed in
+         */
+        range_start = max(start,range_start);
+        found = found_end - range_start;
+
+        if (found > 0) {
+                u64 hole_start = start;
+                u64 hole_len = len;
+
+                em = alloc_extent_map();
+                if (!em) {
+                        err = -ENOMEM;
+                        goto out;
+                }
+                /*
+                 * when btrfs_get_extent can't find anything it
+                 * returns one huge hole
+                 *
+                 * make sure what it found really fits our range, and
+                 * adjust to make sure it is based on the start from
+                 * the caller
+                 */
+                if (hole_em) {
+                        u64 calc_end = extent_map_end(hole_em);
+
+                        if (calc_end <= start || (hole_em->start > end)) {
+                                free_extent_map(hole_em);
+                                hole_em = NULL;
+                        } else {
+                                hole_start = max(hole_em->start, start);
+                                hole_len = calc_end - hole_start;
+                        }
+                }
+                em->bdev = NULL;
+                if (hole_em && range_start > hole_start) {
+                        /* our hole starts before our delalloc, so we
+                         * have to return just the parts of the hole
+                         * that go until  the delalloc starts
+                         */
+                        em->len = min(hole_len,
+                                      range_start - hole_start);
+                        em->start = hole_start;
+                        em->orig_start = hole_start;
+                        /*
+                         * don't adjust block start at all,
+                         * it is fixed at EXTENT_MAP_HOLE
+                         */
+                        em->block_start = hole_em->block_start;
+                        em->block_len = hole_len;
+                } else {
+                        em->start = range_start;
+                        em->len = found;
+                        em->orig_start = range_start;
+                        em->block_start = EXTENT_MAP_DELALLOC;
+                        em->block_len = found;
+                }
+        } else if (hole_em) {
+                return hole_em;
+        }
+out:
+
+        free_extent_map(hole_em);
+        if (err) {
+                free_extent_map(em);
+                return ERR_PTR(err);
+        }
+        return em;
+}
+
 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 *em;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         struct btrfs_key ins;
         u64 alloc_hint;
         int ret;
+        bool insert = false;
 
-        btrfs_drop_extent_cache(inode, start, start + len - 1, 0);
+        /*
+         * 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, 0);
-        if (!trans)
-                return ERR_PTR(-ENOMEM);
+        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;
 
@@ -5227,10 +5388,12 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
                 goto out;
         }
 
-        em = alloc_extent_map(GFP_NOFS);
         if (!em) {
-                em = ERR_PTR(-ENOMEM);
-                goto out;
+                em = alloc_extent_map();
+                if (!em) {
+                        em = ERR_PTR(-ENOMEM);
+                        goto out;
+                }
         }
 
         em->start = start;
@@ -5240,9 +5403,15 @@ static struct extent_map *btrfs_new_extent_direct(struct inode *inode,
         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 (1) {
+        while (insert) {
                 write_lock(&em_tree->lock);
                 ret = add_extent_mapping(em_tree, em);
                 write_unlock(&em_tree->lock);
@@ -5286,7 +5455,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
         if (!path)
                 return -ENOMEM;
 
-        ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
+        ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
                                        offset, 0);
         if (ret < 0)
                 goto out;
@@ -5303,7 +5472,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
         ret = 0;
         leaf = path->nodes[0];
         btrfs_item_key_to_cpu(leaf, &key, slot);
-        if (key.objectid != inode->i_ino ||
+        if (key.objectid != btrfs_ino(inode) ||
             key.type != BTRFS_EXTENT_DATA_KEY) {
                 /* not our file or wrong item type, must cow */
                 goto out;
@@ -5337,7 +5506,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
          * look for other files referencing this extent, if we
          * find any we must cow
          */
-        if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
+        if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
                                   key.offset - backref_offset, disk_bytenr))
                 goto out;
 
@@ -5438,8 +5607,8 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock,
                  * to make sure the current transaction stays open
                  * while we look for nocow cross refs
                  */
-                trans = btrfs_join_transaction(root, 0);
-                if (!trans)
+                trans = btrfs_join_transaction(root);
+                if (IS_ERR(trans))
                         goto must_cow;
 
                 if (can_nocow_odirect(trans, inode, start, len) == 1) {
@@ -5460,8 +5629,7 @@ must_cow:
          * it above
          */
         len = bh_result->b_size;
-        free_extent_map(em);
-        em = btrfs_new_extent_direct(inode, start, len);
+        em = btrfs_new_extent_direct(inode, em, start, len);
         if (IS_ERR(em))
                 return PTR_ERR(em);
         len = min(len, em->len - (start - em->start));
@@ -5490,13 +5658,21 @@ struct btrfs_dio_private {
         u64 bytes;
         u32 *csums;
         void *private;
+
+        /* number of bios pending for this dio */
+        atomic_t pending_bios;
+
+        /* IO errors */
+        int errors;
+
+        struct bio *orig_bio;
 };
 
 static void btrfs_endio_direct_read(struct bio *bio, int err)
 {
+        struct btrfs_dio_private *dip = bio->bi_private;
         struct bio_vec *bvec_end = bio->bi_io_vec + bio->bi_vcnt - 1;
         struct bio_vec *bvec = bio->bi_io_vec;
-        struct btrfs_dio_private *dip = bio->bi_private;
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         u64 start;
@@ -5520,9 +5696,10 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
 
                         flush_dcache_page(bvec->bv_page);
                         if (csum != *private) {
-                                printk(KERN_ERR "btrfs csum failed ino %lu off"
+                                printk(KERN_ERR "btrfs csum failed ino %llu off"
                                       " %llu csum %u private %u\n",
-                                      inode->i_ino, (unsigned long long)start,
+                                      (unsigned long long)btrfs_ino(inode),
+                                      (unsigned long long)start,
                                       csum, *private);
                                 err = -EIO;
                         }
@@ -5539,6 +5716,10 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
 
         kfree(dip->csums);
         kfree(dip);
+
+        /* If we had a csum failure make sure to clear the uptodate flag */
+        if (err)
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
         dio_end_io(bio, err);
 }
 
@@ -5550,20 +5731,23 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
         struct btrfs_trans_handle *trans;
         struct btrfs_ordered_extent *ordered = NULL;
         struct extent_state *cached_state = NULL;
+        u64 ordered_offset = dip->logical_offset;
+        u64 ordered_bytes = dip->bytes;
         int ret;
 
         if (err)
                 goto out_done;
-
-        ret = btrfs_dec_test_ordered_pending(inode, &ordered,
-                                             dip->logical_offset, dip->bytes);
+again:
+        ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
+                                                   &ordered_offset,
+                                                   ordered_bytes);
         if (!ret)
-                goto out_done;
+                goto out_test;
 
         BUG_ON(!ordered);
 
-        trans = btrfs_join_transaction(root, 1);
-        if (!trans) {
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans)) {
                 err = -ENOMEM;
                 goto out;
         }
@@ -5609,8 +5793,10 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
         }
 
         add_pending_csums(trans, inode, ordered->file_offset, &ordered->list);
-        btrfs_ordered_update_i_size(inode, 0, ordered);
-        btrfs_update_inode(trans, root, inode);
+        ret = btrfs_ordered_update_i_size(inode, 0, ordered);
+        if (!ret)
+                btrfs_update_inode(trans, root, inode);
+        ret = 0;
 out_unlock:
         unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset,
                              ordered->file_offset + ordered->len - 1,
@@ -5618,13 +5804,29 @@ out_unlock:
 out:
         btrfs_delalloc_release_metadata(inode, ordered->len);
         btrfs_end_transaction(trans, root);
+        ordered_offset = ordered->file_offset + ordered->len;
         btrfs_put_ordered_extent(ordered);
         btrfs_put_ordered_extent(ordered);
+
+out_test:
+        /*
+         * our bio might span multiple ordered extents.  If we haven't
+         * completed the accounting for the whole dio, go back and try again
+         */
+        if (ordered_offset < dip->logical_offset + dip->bytes) {
+                ordered_bytes = dip->logical_offset + dip->bytes -
+                        ordered_offset;
+                goto again;
+        }
 out_done:
         bio->bi_private = dip->private;
 
         kfree(dip->csums);
         kfree(dip);
+
+        /* If we had an error make sure to clear the uptodate flag */
+        if (err)
+                clear_bit(BIO_UPTODATE, &bio->bi_flags);
         dio_end_io(bio, err);
 }
 
@@ -5639,13 +5841,207 @@ static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
         return 0;
 }
 
+static void btrfs_end_dio_bio(struct bio *bio, int err)
+{
+        struct btrfs_dio_private *dip = bio->bi_private;
+
+        if (err) {
+                printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
+                      "sector %#Lx len %u err no %d\n",
+                      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
+                      (unsigned long long)bio->bi_sector, bio->bi_size, err);
+                dip->errors = 1;
+
+                /*
+                 * before atomic variable goto zero, we must make sure
+                 * dip->errors is perceived to be set.
+                 */
+                smp_mb__before_atomic_dec();
+        }
+
+        /* if there are more bios still pending for this dio, just exit */
+        if (!atomic_dec_and_test(&dip->pending_bios))
+                goto out;
+
+        if (dip->errors)
+                bio_io_error(dip->orig_bio);
+        else {
+                set_bit(BIO_UPTODATE, &dip->orig_bio->bi_flags);
+                bio_endio(dip->orig_bio, 0);
+        }
+out:
+        bio_put(bio);
+}
+
+static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
+                                       u64 first_sector, gfp_t gfp_flags)
+{
+        int nr_vecs = bio_get_nr_vecs(bdev);
+        return btrfs_bio_alloc(bdev, first_sector, nr_vecs, gfp_flags);
+}
+
+static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
+                                         int rw, u64 file_offset, int skip_sum,
+                                         u32 *csums, int async_submit)
+{
+        int write = rw & REQ_WRITE;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        int ret;
+
+        bio_get(bio);
+        ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
+        if (ret)
+                goto err;
+
+        if (skip_sum)
+                goto map;
+
+        if (write && async_submit) {
+                ret = btrfs_wq_submit_bio(root->fs_info,
+                                   inode, rw, bio, 0, 0,
+                                   file_offset,
+                                   __btrfs_submit_bio_start_direct_io,
+                                   __btrfs_submit_bio_done);
+                goto err;
+        } else if (write) {
+                /*
+                 * If we aren't doing async submit, calculate the csum of the
+                 * bio now.
+                 */
+                ret = btrfs_csum_one_bio(root, inode, bio, file_offset, 1);
+                if (ret)
+                        goto err;
+        } else if (!skip_sum) {
+                ret = btrfs_lookup_bio_sums_dio(root, inode, bio,
+                                          file_offset, csums);
+                if (ret)
+                        goto err;
+        }
+
+map:
+        ret = btrfs_map_bio(root, rw, bio, 0, async_submit);
+err:
+        bio_put(bio);
+        return ret;
+}
+
+static int btrfs_submit_direct_hook(int rw, struct btrfs_dio_private *dip,
+                                    int skip_sum)
+{
+        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;
+        u64 start_sector = orig_bio->bi_sector;
+        u64 file_offset = dip->logical_offset;
+        u64 submit_len = 0;
+        u64 map_length;
+        int nr_pages = 0;
+        u32 *csums = dip->csums;
+        int ret = 0;
+        int async_submit = 0;
+        int write = rw & REQ_WRITE;
+
+        map_length = orig_bio->bi_size;
+        ret = btrfs_map_block(map_tree, READ, start_sector << 9,
+                              &map_length, NULL, 0);
+        if (ret) {
+                bio_put(orig_bio);
+                return -EIO;
+        }
+
+        if (map_length >= orig_bio->bi_size) {
+                bio = orig_bio;
+                goto submit;
+        }
+
+        async_submit = 1;
+        bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev, start_sector, GFP_NOFS);
+        if (!bio)
+                return -ENOMEM;
+        bio->bi_private = dip;
+        bio->bi_end_io = btrfs_end_dio_bio;
+        atomic_inc(&dip->pending_bios);
+
+        while (bvec <= (orig_bio->bi_io_vec + orig_bio->bi_vcnt - 1)) {
+                if (unlikely(map_length < submit_len + bvec->bv_len ||
+                    bio_add_page(bio, bvec->bv_page, bvec->bv_len,
+                                 bvec->bv_offset) < bvec->bv_len)) {
+                        /*
+                         * inc the count before we submit the bio so
+                         * we know the end IO handler won't happen before
+                         * we inc the count. Otherwise, the dip might get freed
+                         * before we're done setting it up
+                         */
+                        atomic_inc(&dip->pending_bios);
+                        ret = __btrfs_submit_dio_bio(bio, inode, rw,
+                                                     file_offset, skip_sum,
+                                                     csums, async_submit);
+                        if (ret) {
+                                bio_put(bio);
+                                atomic_dec(&dip->pending_bios);
+                                goto out_err;
+                        }
+
+                        /* Write's use the ordered csums */
+                        if (!write && !skip_sum)
+                                csums = csums + nr_pages;
+                        start_sector += submit_len >> 9;
+                        file_offset += submit_len;
+
+                        submit_len = 0;
+                        nr_pages = 0;
+
+                        bio = btrfs_dio_bio_alloc(orig_bio->bi_bdev,
+                                                  start_sector, GFP_NOFS);
+                        if (!bio)
+                                goto out_err;
+                        bio->bi_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,
+                                              &map_length, NULL, 0);
+                        if (ret) {
+                                bio_put(bio);
+                                goto out_err;
+                        }
+                } else {
+                        submit_len += bvec->bv_len;
+                        nr_pages ++;
+                        bvec++;
+                }
+        }
+
+submit:
+        ret = __btrfs_submit_dio_bio(bio, inode, rw, file_offset, skip_sum,
+                                     csums, async_submit);
+        if (!ret)
+                return 0;
+
+        bio_put(bio);
+out_err:
+        dip->errors = 1;
+        /*
+         * before atomic variable goto zero, we must
+         * make sure dip->errors is perceived to be set.
+         */
+        smp_mb__before_atomic_dec();
+        if (atomic_dec_and_test(&dip->pending_bios))
+                bio_io_error(dip->orig_bio);
+
+        /* bio_end_io() will handle error, so we needn't return it */
+        return 0;
+}
+
 static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
                                 loff_t file_offset)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_dio_private *dip;
         struct bio_vec *bvec = bio->bi_io_vec;
-        u64 start;
         int skip_sum;
         int write = rw & REQ_WRITE;
         int ret = 0;
@@ -5659,9 +6055,11 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
         }
         dip->csums = NULL;
 
-        if (!skip_sum) {
+        /* Write's use the ordered csum stuff, so we don't need dip->csums */
+        if (!write && !skip_sum) {
                 dip->csums = kmalloc(sizeof(u32) * bio->bi_vcnt, GFP_NOFS);
                 if (!dip->csums) {
+                        kfree(dip);
                         ret = -ENOMEM;
                         goto free_ordered;
                 }
@@ -5671,7 +6069,6 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
         dip->inode = inode;
         dip->logical_offset = file_offset;
 
-        start = dip->logical_offset;
         dip->bytes = 0;
         do {
                 dip->bytes += bvec->bv_len;
@@ -5680,36 +6077,18 @@ static void btrfs_submit_direct(int rw, struct bio *bio, struct inode *inode,
 
         dip->disk_bytenr = (u64)bio->bi_sector << 9;
         bio->bi_private = dip;
+        dip->errors = 0;
+        dip->orig_bio = bio;
+        atomic_set(&dip->pending_bios, 0);
 
         if (write)
                 bio->bi_end_io = btrfs_endio_direct_write;
         else
                 bio->bi_end_io = btrfs_endio_direct_read;
 
-        ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
-        if (ret)
-                goto out_err;
-
-        if (write && !skip_sum) {
-                ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
-                                   inode, rw, bio, 0, 0,
-                                   dip->logical_offset,
-                                   __btrfs_submit_bio_start_direct_io,
-                                   __btrfs_submit_bio_done);
-                if (ret)
-                        goto out_err;
+        ret = btrfs_submit_direct_hook(rw, dip, skip_sum);
+        if (!ret)
                 return;
-        } else if (!skip_sum)
-                btrfs_lookup_bio_sums_dio(root, inode, bio,
-                                          dip->logical_offset, dip->csums);
-
-        ret = btrfs_map_bio(root, rw, bio, 0, 1);
-        if (ret)
-                goto out_err;
-        return;
-out_err:
-        kfree(dip->csums);
-        kfree(dip);
 free_ordered:
         /*
          * If this is a write, we need to clean up the reserved space and kill
@@ -5717,8 +6096,7 @@ free_ordered:
          */
         if (write) {
                 struct btrfs_ordered_extent *ordered;
-                ordered = btrfs_lookup_ordered_extent(inode,
-                                                      dip->logical_offset);
+                ordered = btrfs_lookup_ordered_extent(inode, file_offset);
                 if (!test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags) &&
                     !test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags))
                         btrfs_free_reserved_extent(root, ordered->start,
@@ -5734,6 +6112,7 @@ static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *io
                         unsigned long nr_segs)
 {
         int seg;
+        int i;
         size_t size;
         unsigned long addr;
         unsigned blocksize_mask = root->sectorsize - 1;
@@ -5748,8 +6127,22 @@ static ssize_t check_direct_IO(struct btrfs_root *root, int rw, struct kiocb *io
                 addr = (unsigned long)iov[seg].iov_base;
                 size = iov[seg].iov_len;
                 end += size;
-                if ((addr & blocksize_mask) || (size & blocksize_mask)) 
+                if ((addr & blocksize_mask) || (size & blocksize_mask))
                         goto out;
+
+                /* If this is a write we don't need to check anymore */
+                if (rw & WRITE)
+                        continue;
+
+                /*
+                 * Check to make sure we don't have duplicate iov_base's in this
+                 * iovec, if so return EINVAL, otherwise we'll get csum errors
+                 * when reading back.
+                 */
+                for (i = seg + 1; i < nr_segs; i++) {
+                        if (iov[seg].iov_base == iov[i].iov_base)
+                                goto out;
+                }
         }
         retval = 0;
 out:
@@ -5850,7 +6243,7 @@ out:
 static int btrfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                 __u64 start, __u64 len)
 {
-        return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent);
+        return extent_fiemap(inode, fieinfo, start, len, btrfs_get_extent_fiemap);
 }
 
 int btrfs_readpage(struct file *file, struct page *page)
@@ -6100,30 +6493,97 @@ out:
         return ret;
 }
 
-static void btrfs_truncate(struct inode *inode)
+static int btrfs_truncate(struct inode *inode)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct btrfs_block_rsv *rsv;
         int ret;
+        int err = 0;
         struct btrfs_trans_handle *trans;
         unsigned long nr;
         u64 mask = root->sectorsize - 1;
 
-        if (!S_ISREG(inode->i_mode)) {
-                WARN_ON(1);
-                return;
-        }
-
         ret = btrfs_truncate_page(inode->i_mapping, inode->i_size);
         if (ret)
-                return;
+                return ret;
 
         btrfs_wait_ordered_range(inode, inode->i_size & (~mask), (u64)-1);
         btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
 
-        trans = btrfs_start_transaction(root, 0);
-        BUG_ON(IS_ERR(trans));
-        btrfs_set_trans_block_group(trans, inode);
-        trans->block_rsv = root->orphan_block_rsv;
+        /*
+         * Yes ladies and gentelment, this is indeed ugly.  The fact is we have
+         * 3 things going on here
+         *
+         * 1) We need to reserve space for our orphan item and the space to
+         * delete our orphan item.  Lord knows we don't want to have a dangling
+         * orphan item because we didn't reserve space to remove it.
+         *
+         * 2) We need to reserve space to update our inode.
+         *
+         * 3) We need to have something to cache all the space that is going to
+         * be free'd up by the truncate operation, but also have some slack
+         * space reserved in case it uses space during the truncate (thank you
+         * very much snapshotting).
+         *
+         * And we need these to all be seperate.  The fact is we can use alot of
+         * space doing the truncate, and we have no earthly idea how much space
+         * we will use, so we need the truncate reservation to be seperate so it
+         * doesn't end up using space reserved for updating the inode or
+         * removing the orphan item.  We also need to be able to stop the
+         * transaction and start a new one, which means we need to be able to
+         * update the inode several times, and we have no idea of knowing how
+         * many times that will be, so we can't just reserve 1 item for the
+         * entirety of the opration, so that has to be done seperately as well.
+         * Then there is the orphan item, which does indeed need to be held on
+         * to for the whole operation, and we need nobody to touch this reserved
+         * space except the orphan code.
+         *
+         * So that leaves us with
+         *
+         * 1) root->orphan_block_rsv - for the orphan deletion.
+         * 2) rsv - for the truncate reservation, which we will steal from the
+         * transaction reservation.
+         * 3) fs_info->trans_block_rsv - this will have 1 items worth left for
+         * updating the inode.
+         */
+        rsv = btrfs_alloc_block_rsv(root);
+        if (!rsv)
+                return -ENOMEM;
+        btrfs_add_durable_block_rsv(root->fs_info, rsv);
+
+        trans = btrfs_start_transaction(root, 4);
+        if (IS_ERR(trans)) {
+                err = PTR_ERR(trans);
+                goto out;
+        }
+
+        /*
+         * Reserve space for the truncate process.  Truncate should be adding
+         * space, but if there are snapshots it may end up using space.
+         */
+        ret = btrfs_truncate_reserve_metadata(trans, root, rsv);
+        BUG_ON(ret);
+
+        ret = btrfs_orphan_add(trans, inode);
+        if (ret) {
+                btrfs_end_transaction(trans, root);
+                goto out;
+        }
+
+        nr = trans->blocks_used;
+        btrfs_end_transaction(trans, root);
+        btrfs_btree_balance_dirty(root, nr);
+
+        /*
+         * Ok so we've already migrated our bytes over for the truncate, so here
+         * just reserve the one slot we need for updating the inode.
+         */
+        trans = btrfs_start_transaction(root, 1);
+        if (IS_ERR(trans)) {
+                err = PTR_ERR(trans);
+                goto out;
+        }
+        trans->block_rsv = rsv;
 
         /*
          * setattr is responsible for setting the ordered_data_close flag,
@@ -6147,30 +6607,33 @@ static void btrfs_truncate(struct inode *inode)
 
         while (1) {
                 if (!trans) {
-                        trans = btrfs_start_transaction(root, 0);
-                        BUG_ON(IS_ERR(trans));
-                        btrfs_set_trans_block_group(trans, inode);
-                        trans->block_rsv = root->orphan_block_rsv;
-                }
+                        trans = btrfs_start_transaction(root, 3);
+                        if (IS_ERR(trans)) {
+                                err = PTR_ERR(trans);
+                                goto out;
+                        }
 
-                ret = btrfs_block_rsv_check(trans, root,
-                                            root->orphan_block_rsv, 0, 5);
-                if (ret) {
-                        BUG_ON(ret != -EAGAIN);
-                        ret = btrfs_commit_transaction(trans, root);
+                        ret = btrfs_truncate_reserve_metadata(trans, root,
+                                                              rsv);
                         BUG_ON(ret);
-                        trans = NULL;
-                        continue;
+
+                        trans->block_rsv = rsv;
                 }
 
                 ret = btrfs_truncate_inode_items(trans, root, inode,
                                                  inode->i_size,
                                                  BTRFS_EXTENT_DATA_KEY);
-                if (ret != -EAGAIN)
+                if (ret != -EAGAIN) {
+                        err = ret;
                         break;
+                }
 
+                trans->block_rsv = &root->fs_info->trans_block_rsv;
                 ret = btrfs_update_inode(trans, root, inode);
-                BUG_ON(ret);
+                if (ret) {
+                        err = ret;
+                        break;
+                }
 
                 nr = trans->blocks_used;
                 btrfs_end_transaction(trans, root);
@@ -6179,32 +6642,48 @@ static void btrfs_truncate(struct inode *inode)
         }
 
         if (ret == 0 && inode->i_nlink > 0) {
+                trans->block_rsv = root->orphan_block_rsv;
                 ret = btrfs_orphan_del(trans, inode);
-                BUG_ON(ret);
+                if (ret)
+                        err = ret;
+        } else if (ret && inode->i_nlink > 0) {
+                /*
+                 * Failed to do the truncate, remove us from the in memory
+                 * orphan list.
+                 */
+                ret = btrfs_orphan_del(NULL, inode);
         }
 
+        trans->block_rsv = &root->fs_info->trans_block_rsv;
         ret = btrfs_update_inode(trans, root, inode);
-        BUG_ON(ret);
+        if (ret && !err)
+                err = ret;
 
         nr = trans->blocks_used;
         ret = btrfs_end_transaction_throttle(trans, root);
-        BUG_ON(ret);
         btrfs_btree_balance_dirty(root, nr);
+
+out:
+        btrfs_free_block_rsv(root, rsv);
+
+        if (ret && !err)
+                err = ret;
+
+        return err;
 }
 
 /*
  * create a new subvolume directory/inode (helper for the ioctl).
  */
 int btrfs_create_subvol_root(struct btrfs_trans_handle *trans,
-                             struct btrfs_root *new_root,
-                             u64 new_dirid, u64 alloc_hint)
+                             struct btrfs_root *new_root, u64 new_dirid)
 {
         struct inode *inode;
         int err;
         u64 index = 0;
 
         inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid,
-                                new_dirid, alloc_hint, S_IFDIR | 0700, &index);
+                                new_dirid, S_IFDIR | 0700, &index);
         if (IS_ERR(inode))
                 return PTR_ERR(inode);
         inode->i_op = &btrfs_dir_inode_operations;
@@ -6256,19 +6735,21 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->index_cnt = (u64)-1;
         ei->last_unlink_trans = 0;
 
-        spin_lock_init(&ei->accounting_lock);
         atomic_set(&ei->outstanding_extents, 0);
-        ei->reserved_extents = 0;
+        atomic_set(&ei->reserved_extents, 0);
 
         ei->ordered_data_close = 0;
         ei->orphan_meta_reserved = 0;
         ei->dummy_inode = 0;
-        ei->force_compress = 0;
+        ei->in_defrag = 0;
+        ei->force_compress = BTRFS_COMPRESS_NONE;
+
+        ei->delayed_node = NULL;
 
         inode = &ei->vfs_inode;
-        extent_map_tree_init(&ei->extent_tree, GFP_NOFS);
-        extent_io_tree_init(&ei->io_tree, &inode->i_data, GFP_NOFS);
-        extent_io_tree_init(&ei->io_failure_tree, &inode->i_data, GFP_NOFS);
+        extent_map_tree_init(&ei->extent_tree);
+        extent_io_tree_init(&ei->io_tree, &inode->i_data);
+        extent_io_tree_init(&ei->io_failure_tree, &inode->i_data);
         mutex_init(&ei->log_mutex);
         btrfs_ordered_inode_tree_init(&ei->ordered_tree);
         INIT_LIST_HEAD(&ei->i_orphan);
@@ -6279,6 +6760,13 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         return inode;
 }
 
+static void btrfs_i_callback(struct rcu_head *head)
+{
+        struct inode *inode = container_of(head, struct inode, i_rcu);
+        INIT_LIST_HEAD(&inode->i_dentry);
+        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
+}
+
 void btrfs_destroy_inode(struct inode *inode)
 {
         struct btrfs_ordered_extent *ordered;
@@ -6287,7 +6775,7 @@ void btrfs_destroy_inode(struct inode *inode)
         WARN_ON(!list_empty(&inode->i_dentry));
         WARN_ON(inode->i_data.nrpages);
         WARN_ON(atomic_read(&BTRFS_I(inode)->outstanding_extents));
-        WARN_ON(BTRFS_I(inode)->reserved_extents);
+        WARN_ON(atomic_read(&BTRFS_I(inode)->reserved_extents));
 
         /*
          * This can happen where we create an inode, but somebody else also
@@ -6310,8 +6798,8 @@ void btrfs_destroy_inode(struct inode *inode)
 
         spin_lock(&root->orphan_lock);
         if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
-                printk(KERN_INFO "BTRFS: inode %lu still on the orphan list\n",
-                       inode->i_ino);
+                printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
+                       (unsigned long long)btrfs_ino(inode));
                 list_del_init(&BTRFS_I(inode)->i_orphan);
         }
         spin_unlock(&root->orphan_lock);
@@ -6333,14 +6821,16 @@ void btrfs_destroy_inode(struct inode *inode)
         inode_tree_del(inode);
         btrfs_drop_extent_cache(inode, 0, (u64)-1, 0);
 free:
-        kmem_cache_free(btrfs_inode_cachep, BTRFS_I(inode));
+        btrfs_remove_delayed_node(inode);
+        call_rcu(&inode->i_rcu, btrfs_i_callback);
 }
 
 int btrfs_drop_inode(struct inode *inode)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
 
-        if (btrfs_root_refs(&root->root_item) == 0)
+        if (btrfs_root_refs(&root->root_item) == 0 &&
+            !is_free_space_inode(root, inode))
                 return 1;
         else
                 return generic_drop_inode(inode);
@@ -6363,6 +6853,8 @@ void btrfs_destroy_cachep(void)
                 kmem_cache_destroy(btrfs_transaction_cachep);
         if (btrfs_path_cachep)
                 kmem_cache_destroy(btrfs_path_cachep);
+        if (btrfs_free_space_cachep)
+                kmem_cache_destroy(btrfs_free_space_cachep);
 }
 
 int btrfs_init_cachep(void)
@@ -6391,6 +6883,12 @@ int btrfs_init_cachep(void)
         if (!btrfs_path_cachep)
                 goto fail;
 
+        btrfs_free_space_cachep = kmem_cache_create("btrfs_free_space_cache",
+                        sizeof(struct btrfs_free_space), 0,
+                        SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, NULL);
+        if (!btrfs_free_space_cachep)
+                goto fail;
+
         return 0;
 fail:
         btrfs_destroy_cachep();
@@ -6409,6 +6907,26 @@ static int btrfs_getattr(struct vfsmount *mnt,
         return 0;
 }
 
+/*
+ * If a file is moved, it will inherit the cow and compression flags of the new
+ * directory.
+ */
+static void fixup_inode_flags(struct inode *dir, struct inode *inode)
+{
+        struct btrfs_inode *b_dir = BTRFS_I(dir);
+        struct btrfs_inode *b_inode = BTRFS_I(inode);
+
+        if (b_dir->flags & BTRFS_INODE_NODATACOW)
+                b_inode->flags |= BTRFS_INODE_NODATACOW;
+        else
+                b_inode->flags &= ~BTRFS_INODE_NODATACOW;
+
+        if (b_dir->flags & BTRFS_INODE_COMPRESS)
+                b_inode->flags |= BTRFS_INODE_COMPRESS;
+        else
+                b_inode->flags &= ~BTRFS_INODE_COMPRESS;
+}
+
 static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                            struct inode *new_dir, struct dentry *new_dentry)
 {
@@ -6421,16 +6939,17 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         u64 index = 0;
         u64 root_objectid;
         int ret;
+        u64 old_ino = btrfs_ino(old_inode);
 
-        if (new_dir->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
+        if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
                 return -EPERM;
 
         /* we only allow rename subvolume link between subvolumes */
-        if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
+        if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
                 return -EXDEV;
 
-        if (old_inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
-            (new_inode && new_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID))
+        if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
+            (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
                 return -ENOTEMPTY;
 
         if (S_ISDIR(old_inode->i_mode) && new_inode &&
@@ -6446,7 +6965,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 filemap_flush(old_inode->i_mapping);
 
         /* close the racy window with snapshot create/destroy ioctl */
-        if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+        if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
                 down_read(&root->fs_info->subvol_sem);
         /*
          * We want to reserve the absolute worst case amount of items.  So if
@@ -6457,10 +6976,10 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
          * should cover the worst case number of items we'll modify.
          */
         trans = btrfs_start_transaction(root, 20);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
-
-        btrfs_set_trans_block_group(trans, new_dir);
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                goto out_notrans;
+        }
 
         if (dest != root)
                 btrfs_record_root_in_trans(trans, dest);
@@ -6469,15 +6988,15 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (ret)
                 goto out_fail;
 
-        if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 /* force full log commit if subvolume involved. */
                 root->fs_info->last_trans_log_full_commit = trans->transid;
         } else {
                 ret = btrfs_insert_inode_ref(trans, dest,
                                              new_dentry->d_name.name,
                                              new_dentry->d_name.len,
-                                             old_inode->i_ino,
-                                             new_dir->i_ino, index);
+                                             old_ino,
+                                             btrfs_ino(new_dir), index);
                 if (ret)
                         goto out_fail;
                 /*
@@ -6493,10 +7012,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
          * make sure the inode gets flushed if it is replacing
          * something.
          */
-        if (new_inode && new_inode->i_size &&
-            old_inode && S_ISREG(old_inode->i_mode)) {
+        if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
                 btrfs_add_ordered_operation(trans, root, old_inode);
-        }
 
         old_dir->i_ctime = old_dir->i_mtime = ctime;
         new_dir->i_ctime = new_dir->i_mtime = ctime;
@@ -6505,23 +7022,24 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (old_dentry->d_parent != new_dentry->d_parent)
                 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
 
-        if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
                 ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
                                         old_dentry->d_name.name,
                                         old_dentry->d_name.len);
         } else {
-                btrfs_inc_nlink(old_dentry->d_inode);
-                ret = btrfs_unlink_inode(trans, root, old_dir,
-                                         old_dentry->d_inode,
-                                         old_dentry->d_name.name,
-                                         old_dentry->d_name.len);
+                ret = __btrfs_unlink_inode(trans, root, old_dir,
+                                        old_dentry->d_inode,
+                                        old_dentry->d_name.name,
+                                        old_dentry->d_name.len);
+                if (!ret)
+                        ret = btrfs_update_inode(trans, root, old_inode);
         }
         BUG_ON(ret);
 
         if (new_inode) {
                 new_inode->i_ctime = CURRENT_TIME;
-                if (unlikely(new_inode->i_ino ==
+                if (unlikely(btrfs_ino(new_inode) ==
                              BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
                         root_objectid = BTRFS_I(new_inode)->location.objectid;
                         ret = btrfs_unlink_subvol(trans, dest, new_dir,
@@ -6542,20 +7060,23 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 }
         }
 
+        fixup_inode_flags(new_dir, old_inode);
+
         ret = btrfs_add_link(trans, new_dir, old_inode,
                              new_dentry->d_name.name,
                              new_dentry->d_name.len, 0, index);
         BUG_ON(ret);
 
-        if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) {
-                btrfs_log_new_name(trans, old_inode, old_dir,
-                                   new_dentry->d_parent);
+        if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
+                struct dentry *parent = dget_parent(new_dentry);
+                btrfs_log_new_name(trans, old_inode, old_dir, parent);
+                dput(parent);
                 btrfs_end_log_trans(root);
         }
 out_fail:
         btrfs_end_transaction_throttle(trans, root);
-
-        if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+out_notrans:
+        if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
                 up_read(&root->fs_info->subvol_sem);
 
         return ret;
@@ -6609,38 +7130,6 @@ int btrfs_start_delalloc_inodes(struct btrfs_root *root, int delay_iput)
         return 0;
 }
 
-int btrfs_start_one_delalloc_inode(struct btrfs_root *root, int delay_iput)
-{
-        struct btrfs_inode *binode;
-        struct inode *inode = NULL;
-
-        spin_lock(&root->fs_info->delalloc_lock);
-        while (!list_empty(&root->fs_info->delalloc_inodes)) {
-                binode = list_entry(root->fs_info->delalloc_inodes.next,
-                                    struct btrfs_inode, delalloc_inodes);
-                inode = igrab(&binode->vfs_inode);
-                if (inode) {
-                        list_move_tail(&binode->delalloc_inodes,
-                                       &root->fs_info->delalloc_inodes);
-                        break;
-                }
-
-                list_del_init(&binode->delalloc_inodes);
-                cond_resched_lock(&root->fs_info->delalloc_lock);
-        }
-        spin_unlock(&root->fs_info->delalloc_lock);
-
-        if (inode) {
-                write_inode_now(inode, 0);
-                if (delay_iput)
-                        btrfs_add_delayed_iput(inode);
-                else
-                        iput(inode);
-                return 1;
-        }
-        return 0;
-}
-
 static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                          const char *symname)
 {
@@ -6664,9 +7153,6 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
         if (name_len > BTRFS_MAX_INLINE_DATA_SIZE(root))
                 return -ENAMETOOLONG;
 
-        err = btrfs_find_free_objectid(NULL, root, dir->i_ino, &objectid);
-        if (err)
-                return err;
         /*
          * 2 items for inode item and ref
          * 2 items for dir items
@@ -6676,25 +7162,25 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
 
-        btrfs_set_trans_block_group(trans, dir);
+        err = btrfs_find_free_ino(root, &objectid);
+        if (err)
+                goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len,
-                                dentry->d_parent->d_inode->i_ino, objectid,
-                                BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
-                                &index);
-        err = PTR_ERR(inode);
-        if (IS_ERR(inode))
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
+                                S_IFLNK|S_IRWXUGO, &index);
+        if (IS_ERR(inode)) {
+                err = PTR_ERR(inode);
                 goto out_unlock;
+        }
 
-        err = btrfs_init_inode_security(trans, inode, dir);
+        err = btrfs_init_inode_security(trans, inode, dir, &dentry->d_name);
         if (err) {
                 drop_inode = 1;
                 goto out_unlock;
         }
 
-        btrfs_set_trans_block_group(trans, inode);
-        err = btrfs_add_nondir(trans, dentry, inode, 0, index);
+        err = btrfs_add_nondir(trans, dir, dentry, inode, 0, index);
         if (err)
                 drop_inode = 1;
         else {
@@ -6704,14 +7190,12 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                 inode->i_op = &btrfs_file_inode_operations;
                 BTRFS_I(inode)->io_tree.ops = &btrfs_extent_io_ops;
         }
-        btrfs_update_inode_block_group(trans, inode);
-        btrfs_update_inode_block_group(trans, dir);
         if (drop_inode)
                 goto out_unlock;
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         key.offset = 0;
         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
         datasize = btrfs_file_extent_calc_inline_size(name_len);
@@ -6719,6 +7203,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                                       datasize);
         if (err) {
                 drop_inode = 1;
+                btrfs_free_path(path);
                 goto out_unlock;
         }
         leaf = path->nodes[0];
@@ -6757,27 +7242,34 @@ out_unlock:
         return err;
 }
 
-int btrfs_prealloc_file_range(struct inode *inode, int mode,
-                              u64 start, u64 num_bytes, u64 min_size,
-                              loff_t actual_len, u64 *alloc_hint)
+static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
+                                       u64 start, u64 num_bytes, u64 min_size,
+                                       loff_t actual_len, u64 *alloc_hint,
+                                       struct btrfs_trans_handle *trans)
 {
-        struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_key ins;
         u64 cur_offset = start;
+        u64 i_size;
         int ret = 0;
+        bool own_trans = true;
 
+        if (trans)
+                own_trans = false;
         while (num_bytes > 0) {
-                trans = btrfs_start_transaction(root, 3);
-                if (IS_ERR(trans)) {
-                        ret = PTR_ERR(trans);
-                        break;
+                if (own_trans) {
+                        trans = btrfs_start_transaction(root, 3);
+                        if (IS_ERR(trans)) {
+                                ret = PTR_ERR(trans);
+                                break;
+                        }
                 }
 
                 ret = btrfs_reserve_extent(trans, root, num_bytes, min_size,
                                            0, *alloc_hint, (u64)-1, &ins, 1);
                 if (ret) {
-                        btrfs_end_transaction(trans, root);
+                        if (own_trans)
+                                btrfs_end_transaction(trans, root);
                         break;
                 }
 
@@ -6800,121 +7292,38 @@ int btrfs_prealloc_file_range(struct inode *inode, int mode,
                     (actual_len > inode->i_size) &&
                     (cur_offset > inode->i_size)) {
                         if (cur_offset > actual_len)
-                                i_size_write(inode, actual_len);
+                                i_size = actual_len;
                         else
-                                i_size_write(inode, cur_offset);
-                        i_size_write(inode, cur_offset);
-                        btrfs_ordered_update_i_size(inode, cur_offset, NULL);
+                                i_size = cur_offset;
+                        i_size_write(inode, i_size);
+                        btrfs_ordered_update_i_size(inode, i_size, NULL);
                 }
 
                 ret = btrfs_update_inode(trans, root, inode);
                 BUG_ON(ret);
 
-                btrfs_end_transaction(trans, root);
+                if (own_trans)
+                        btrfs_end_transaction(trans, root);
         }
         return ret;
 }
 
-static long btrfs_fallocate(struct inode *inode, int mode,
-                            loff_t offset, loff_t len)
+int btrfs_prealloc_file_range(struct inode *inode, int mode,
+                              u64 start, u64 num_bytes, u64 min_size,
+                              loff_t actual_len, u64 *alloc_hint)
 {
-        struct extent_state *cached_state = NULL;
-        u64 cur_offset;
-        u64 last_byte;
-        u64 alloc_start;
-        u64 alloc_end;
-        u64 alloc_hint = 0;
-        u64 locked_end;
-        u64 mask = BTRFS_I(inode)->root->sectorsize - 1;
-        struct extent_map *em;
-        int ret;
-
-        alloc_start = offset & ~mask;
-        alloc_end =  (offset + len + mask) & ~mask;
-
-        /*
-         * wait for ordered IO before we have any locks.  We'll loop again
-         * below with the locks held.
-         */
-        btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);
-
-        mutex_lock(&inode->i_mutex);
-        if (alloc_start > inode->i_size) {
-                ret = btrfs_cont_expand(inode, alloc_start);
-                if (ret)
-                        goto out;
-        }
-
-        ret = btrfs_check_data_free_space(inode, alloc_end - alloc_start);
-        if (ret)
-                goto out;
-
-        locked_end = alloc_end - 1;
-        while (1) {
-                struct btrfs_ordered_extent *ordered;
-
-                /* the extent lock is ordered inside the running
-                 * transaction
-                 */
-                lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,
-                                 locked_end, 0, &cached_state, GFP_NOFS);
-                ordered = btrfs_lookup_first_ordered_extent(inode,
-                                                            alloc_end - 1);
-                if (ordered &&
-                    ordered->file_offset + ordered->len > alloc_start &&
-                    ordered->file_offset < alloc_end) {
-                        btrfs_put_ordered_extent(ordered);
-                        unlock_extent_cached(&BTRFS_I(inode)->io_tree,
-                                             alloc_start, locked_end,
-                                             &cached_state, GFP_NOFS);
-                        /*
-                         * we can't wait on the range with the transaction
-                         * running or with the extent lock held
-                         */
-                        btrfs_wait_ordered_range(inode, alloc_start,
-                                                 alloc_end - alloc_start);
-                } else {
-                        if (ordered)
-                                btrfs_put_ordered_extent(ordered);
-                        break;
-                }
-        }
-
-        cur_offset = alloc_start;
-        while (1) {
-                em = btrfs_get_extent(inode, NULL, 0, cur_offset,
-                                      alloc_end - cur_offset, 0);
-                BUG_ON(IS_ERR(em) || !em);
-                last_byte = min(extent_map_end(em), alloc_end);
-                last_byte = (last_byte + mask) & ~mask;
-                if (em->block_start == EXTENT_MAP_HOLE ||
-                    (cur_offset >= inode->i_size &&
-                     !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
-                        ret = btrfs_prealloc_file_range(inode, mode, cur_offset,
-                                                        last_byte - cur_offset,
-                                                        1 << inode->i_blkbits,
-                                                        offset + len,
-                                                        &alloc_hint);
-                        if (ret < 0) {
-                                free_extent_map(em);
-                                break;
-                        }
-                }
-                free_extent_map(em);
-
-                cur_offset = last_byte;
-                if (cur_offset >= alloc_end) {
-                        ret = 0;
-                        break;
-                }
-        }
-        unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
-                             &cached_state, GFP_NOFS);
+        return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
+                                           min_size, actual_len, alloc_hint,
+                                           NULL);
+}
 
-        btrfs_free_reserved_data_space(inode, alloc_end - alloc_start);
-out:
-        mutex_unlock(&inode->i_mutex);
-        return ret;
+int btrfs_prealloc_file_range_trans(struct inode *inode,
+                                    struct btrfs_trans_handle *trans, int mode,
+                                    u64 start, u64 num_bytes, u64 min_size,
+                                    loff_t actual_len, u64 *alloc_hint)
+{
+        return __btrfs_prealloc_file_range(inode, mode, start, num_bytes,
+                                           min_size, actual_len, alloc_hint, trans);
 }
 
 static int btrfs_set_page_dirty(struct page *page)
@@ -6922,11 +7331,15 @@ static int btrfs_set_page_dirty(struct page *page)
         return __set_page_dirty_nobuffers(page);
 }
 
-static int btrfs_permission(struct inode *inode, int mask)
+static int btrfs_permission(struct inode *inode, int mask, unsigned int flags)
 {
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+
+        if (btrfs_root_readonly(root) && (mask & MAY_WRITE))
+                return -EROFS;
         if ((BTRFS_I(inode)->flags & BTRFS_INODE_READONLY) && (mask & MAY_WRITE))
                 return -EACCES;
-        return generic_permission(inode, mask, btrfs_check_acl);
+        return generic_permission(inode, mask, flags, btrfs_check_acl);
 }
 
 static const struct inode_operations btrfs_dir_inode_operations = {
@@ -6995,7 +7408,6 @@ static const struct address_space_operations btrfs_aops = {
         .writepage      = btrfs_writepage,
         .writepages     = btrfs_writepages,
         .readpages      = btrfs_readpages,
-        .sync_page      = block_sync_page,
         .direct_IO      = btrfs_direct_IO,
         .invalidatepage = btrfs_invalidatepage,
         .releasepage    = btrfs_releasepage,
@@ -7011,7 +7423,6 @@ static const struct address_space_operations btrfs_symlink_aops = {
 };
 
 static const struct inode_operations btrfs_file_inode_operations = {
-        .truncate       = btrfs_truncate,
         .getattr        = btrfs_getattr,
         .setattr        = btrfs_setattr,
         .setxattr       = btrfs_setxattr,
@@ -7019,7 +7430,6 @@ static const struct inode_operations btrfs_file_inode_operations = {
         .listxattr      = btrfs_listxattr,
         .removexattr    = btrfs_removexattr,
         .permission     = btrfs_permission,
-        .fallocate      = btrfs_fallocate,
         .fiemap         = btrfs_fiemap,
 };
 static const struct inode_operations btrfs_special_inode_operations = {
@@ -7035,6 +7445,7 @@ static const struct inode_operations btrfs_symlink_inode_operations = {
         .readlink       = generic_readlink,
         .follow_link    = page_follow_link_light,
         .put_link       = page_put_link,
+        .getattr        = btrfs_getattr,
         .permission     = btrfs_permission,
         .setxattr       = btrfs_setxattr,
         .getxattr       = btrfs_getxattr,