Merge branch 'integration' into for-linus

1 files changed, 34 insertions, 56 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 3601f0aebddf..586cf6a43855 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -750,15 +750,6 @@ 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
@@ -791,7 +782,7 @@ static noinline int cow_file_range(struct inode *inode,
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         int ret = 0;
 
-        BUG_ON(is_free_space_inode(root, inode));
+        BUG_ON(btrfs_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;
@@ -1072,7 +1063,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         path = btrfs_alloc_path();
         BUG_ON(!path);
 
-        nolock = is_free_space_inode(root, inode);
+        nolock = btrfs_is_free_space_inode(root, inode);
 
         if (nolock)
                 trans = btrfs_join_transaction_nolock(root);
@@ -1298,7 +1289,9 @@ static int btrfs_split_extent_hook(struct inode *inode,
         if (!(orig->state & EXTENT_DELALLOC))
                 return 0;
 
-        atomic_inc(&BTRFS_I(inode)->outstanding_extents);
+        spin_lock(&BTRFS_I(inode)->lock);
+        BTRFS_I(inode)->outstanding_extents++;
+        spin_unlock(&BTRFS_I(inode)->lock);
         return 0;
 }
 
@@ -1316,7 +1309,9 @@ static int btrfs_merge_extent_hook(struct inode *inode,
         if (!(other->state & EXTENT_DELALLOC))
                 return 0;
 
-        atomic_dec(&BTRFS_I(inode)->outstanding_extents);
+        spin_lock(&BTRFS_I(inode)->lock);
+        BTRFS_I(inode)->outstanding_extents--;
+        spin_unlock(&BTRFS_I(inode)->lock);
         return 0;
 }
 
@@ -1337,12 +1332,15 @@ static int btrfs_set_bit_hook(struct inode *inode,
         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);
+                bool do_list = !btrfs_is_free_space_inode(root, inode);
 
-                if (*bits & EXTENT_FIRST_DELALLOC)
+                if (*bits & EXTENT_FIRST_DELALLOC) {
                         *bits &= ~EXTENT_FIRST_DELALLOC;
-                else
-                        atomic_inc(&BTRFS_I(inode)->outstanding_extents);
+                } else {
+                        spin_lock(&BTRFS_I(inode)->lock);
+                        BTRFS_I(inode)->outstanding_extents++;
+                        spin_unlock(&BTRFS_I(inode)->lock);
+                }
 
                 spin_lock(&root->fs_info->delalloc_lock);
                 BTRFS_I(inode)->delalloc_bytes += len;
@@ -1370,12 +1368,15 @@ static int btrfs_clear_bit_hook(struct inode *inode,
         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);
+                bool do_list = !btrfs_is_free_space_inode(root, inode);
 
-                if (*bits & EXTENT_FIRST_DELALLOC)
+                if (*bits & EXTENT_FIRST_DELALLOC) {
                         *bits &= ~EXTENT_FIRST_DELALLOC;
-                else if (!(*bits & EXTENT_DO_ACCOUNTING))
-                        atomic_dec(&BTRFS_I(inode)->outstanding_extents);
+                } else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
+                        spin_lock(&BTRFS_I(inode)->lock);
+                        BTRFS_I(inode)->outstanding_extents--;
+                        spin_unlock(&BTRFS_I(inode)->lock);
+                }
 
                 if (*bits & EXTENT_DO_ACCOUNTING)
                         btrfs_delalloc_release_metadata(inode, len);
@@ -1477,7 +1478,7 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 
         skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
-        if (is_free_space_inode(root, inode))
+        if (btrfs_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);
@@ -1726,7 +1727,7 @@ 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);
+        nolock = btrfs_is_free_space_inode(root, inode);
 
         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
                 BUG_ON(!list_empty(&ordered_extent->list));
@@ -2531,13 +2532,6 @@ static void btrfs_read_locked_inode(struct inode *inode)
 
         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);
         inode->i_uid = btrfs_inode_uid(leaf, inode_item);
@@ -2575,11 +2569,6 @@ cache_acl:
         if (!maybe_acls)
                 cache_no_acl(inode);
 
-        if (leaf->map_token) {
-                unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
-                leaf->map_token = NULL;
-        }
-
         btrfs_free_path(path);
 
         switch (inode->i_mode & S_IFMT) {
@@ -2624,13 +2613,6 @@ 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);
@@ -2659,11 +2641,6 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
         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, 0);
-
-        if (leaf->map_token) {
-                unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
-                leaf->map_token = NULL;
-        }
 }
 
 /*
@@ -2684,7 +2661,7 @@ noinline int btrfs_update_inode(struct btrfs_trans_handle *trans,
          * The data relocation inode should also be directly updated
          * without delay
          */
-        if (!is_free_space_inode(root, inode)
+        if (!btrfs_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)
@@ -3398,7 +3375,7 @@ static int btrfs_truncate_page(struct address_space *mapping, loff_t from)
 
         ret = -ENOMEM;
 again:
-        page = grab_cache_page(mapping, index);
+        page = find_or_create_page(mapping, index, GFP_NOFS);
         if (!page) {
                 btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
                 goto out;
@@ -3634,7 +3611,7 @@ void btrfs_evict_inode(struct inode *inode)
 
         truncate_inode_pages(&inode->i_data, 0);
         if (inode->i_nlink && (btrfs_root_refs(&root->root_item) != 0 ||
-                               is_free_space_inode(root, inode)))
+                               btrfs_is_free_space_inode(root, inode)))
                 goto no_delete;
 
         if (is_bad_inode(inode)) {
@@ -4277,7 +4254,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
         if (BTRFS_I(inode)->dummy_inode)
                 return 0;
 
-        if (btrfs_fs_closing(root->fs_info) && is_free_space_inode(root, inode))
+        if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(root, inode))
                 nolock = true;
 
         if (wbc->sync_mode == WB_SYNC_ALL) {
@@ -6735,8 +6712,9 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->index_cnt = (u64)-1;
         ei->last_unlink_trans = 0;
 
-        atomic_set(&ei->outstanding_extents, 0);
-        atomic_set(&ei->reserved_extents, 0);
+        spin_lock_init(&ei->lock);
+        ei->outstanding_extents = 0;
+        ei->reserved_extents = 0;
 
         ei->ordered_data_close = 0;
         ei->orphan_meta_reserved = 0;
@@ -6774,8 +6752,8 @@ 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(atomic_read(&BTRFS_I(inode)->reserved_extents));
+        WARN_ON(BTRFS_I(inode)->outstanding_extents);
+        WARN_ON(BTRFS_I(inode)->reserved_extents);
 
         /*
          * This can happen where we create an inode, but somebody else also
@@ -6830,7 +6808,7 @@ int btrfs_drop_inode(struct inode *inode)
         struct btrfs_root *root = BTRFS_I(inode)->root;
 
         if (btrfs_root_refs(&root->root_item) == 0 &&
-            !is_free_space_inode(root, inode))
+            !btrfs_is_free_space_inode(root, inode))
                 return 1;
         else
                 return generic_drop_inode(inode);