1 files changed, 139 insertions, 7 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 43192e10cc43..56f00a25c003 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -59,6 +59,7 @@
 #include "backref.h"
 #include "hash.h"
 #include "props.h"
+#include "qgroup.h"
 
 struct btrfs_iget_args {
         struct btrfs_key *location;
@@ -470,7 +471,7 @@ again:
          */
         if (inode_need_compress(inode)) {
                 WARN_ON(pages);
-                pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
+                pages = kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS);
                 if (!pages) {
                         /* just bail out to the uncompressed code */
                         goto cont;
@@ -752,7 +753,6 @@ retry:
                         }
                         goto out_free;
                 }
-
                 /*
                  * here we're doing allocation and writeback of the
                  * compressed pages
@@ -3110,6 +3110,8 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
         if (empty)
                 return;
 
+        down_read(&fs_info->delayed_iput_sem);
+
         spin_lock(&fs_info->delayed_iput_lock);
         list_splice_init(&fs_info->delayed_iputs, &list);
         spin_unlock(&fs_info->delayed_iput_lock);
@@ -3120,6 +3122,8 @@ void btrfs_run_delayed_iputs(struct btrfs_root *root)
                 iput(delayed->inode);
                 kfree(delayed);
         }
+
+        up_read(&root->fs_info->delayed_iput_sem);
 }
 
 /*
@@ -4162,6 +4166,21 @@ out:
         return err;
 }
 
+static int truncate_space_check(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root,
+                                u64 bytes_deleted)
+{
+        int ret;
+
+        bytes_deleted = btrfs_csum_bytes_to_leaves(root, bytes_deleted);
+        ret = btrfs_block_rsv_add(root, &root->fs_info->trans_block_rsv,
+                                  bytes_deleted, BTRFS_RESERVE_NO_FLUSH);
+        if (!ret)
+                trans->bytes_reserved += bytes_deleted;
+        return ret;
+
+}
+
 /*
  * 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
@@ -4197,9 +4216,21 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         int ret;
         int err = 0;
         u64 ino = btrfs_ino(inode);
+        u64 bytes_deleted = 0;
+        bool be_nice = 0;
+        bool should_throttle = 0;
+        bool should_end = 0;
 
         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
 
+        /*
+         * for non-free space inodes and ref cows, we want to back off from
+         * time to time
+         */
+        if (!btrfs_is_free_space_inode(inode) &&
+            test_bit(BTRFS_ROOT_REF_COWS, &root->state))
+                be_nice = 1;
+
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
@@ -4229,6 +4260,19 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         key.type = (u8)-1;
 
 search_again:
+        /*
+         * with a 16K leaf size and 128MB extents, you can actually queue
+         * up a huge file in a single leaf.  Most of the time that
+         * bytes_deleted is > 0, it will be huge by the time we get here
+         */
+        if (be_nice && bytes_deleted > 32 * 1024 * 1024) {
+                if (btrfs_should_end_transaction(trans, root)) {
+                        err = -EAGAIN;
+                        goto error;
+                }
+        }
+
+
         path->leave_spinning = 1;
         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
         if (ret < 0) {
@@ -4371,22 +4415,39 @@ delete:
                 } else {
                         break;
                 }
+                should_throttle = 0;
+
                 if (found_extent &&
                     (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
                      root == root->fs_info->tree_root)) {
                         btrfs_set_path_blocking(path);
+                        bytes_deleted += extent_num_bytes;
                         ret = btrfs_free_extent(trans, root, extent_start,
                                                 extent_num_bytes, 0,
                                                 btrfs_header_owner(leaf),
                                                 ino, extent_offset, 0);
                         BUG_ON(ret);
+                        if (btrfs_should_throttle_delayed_refs(trans, root))
+                                btrfs_async_run_delayed_refs(root,
+                                        trans->delayed_ref_updates * 2, 0);
+                        if (be_nice) {
+                                if (truncate_space_check(trans, root,
+                                                         extent_num_bytes)) {
+                                        should_end = 1;
+                                }
+                                if (btrfs_should_throttle_delayed_refs(trans,
+                                                                       root)) {
+                                        should_throttle = 1;
+                                }
+                        }
                 }
 
                 if (found_type == BTRFS_INODE_ITEM_KEY)
                         break;
 
                 if (path->slots[0] == 0 ||
-                    path->slots[0] != pending_del_slot) {
+                    path->slots[0] != pending_del_slot ||
+                    should_throttle || should_end) {
                         if (pending_del_nr) {
                                 ret = btrfs_del_items(trans, root, path,
                                                 pending_del_slot,
@@ -4399,6 +4460,23 @@ delete:
                                 pending_del_nr = 0;
                         }
                         btrfs_release_path(path);
+                        if (should_throttle) {
+                                unsigned long updates = trans->delayed_ref_updates;
+                                if (updates) {
+                                        trans->delayed_ref_updates = 0;
+                                        ret = btrfs_run_delayed_refs(trans, root, updates * 2);
+                                        if (ret && !err)
+                                                err = ret;
+                                }
+                        }
+                        /*
+                         * if we failed to refill our space rsv, bail out
+                         * and let the transaction restart
+                         */
+                        if (should_end) {
+                                err = -EAGAIN;
+                                goto error;
+                        }
                         goto search_again;
                 } else {
                         path->slots[0]--;
@@ -4415,7 +4493,18 @@ error:
         if (last_size != (u64)-1 &&
             root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID)
                 btrfs_ordered_update_i_size(inode, last_size, NULL);
+
         btrfs_free_path(path);
+
+        if (be_nice && bytes_deleted > 32 * 1024 * 1024) {
+                unsigned long updates = trans->delayed_ref_updates;
+                if (updates) {
+                        trans->delayed_ref_updates = 0;
+                        ret = btrfs_run_delayed_refs(trans, root, updates * 2);
+                        if (ret && !err)
+                                err = ret;
+                }
+        }
         return err;
 }
 
@@ -4924,6 +5013,7 @@ void btrfs_evict_inode(struct inode *inode)
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_block_rsv *rsv, *global_rsv;
+        int steal_from_global = 0;
         u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
         int ret;
 
@@ -4991,9 +5081,20 @@ void btrfs_evict_inode(struct inode *inode)
                  * hard as possible to get this to work.
                  */
                 if (ret)
-                        ret = btrfs_block_rsv_migrate(global_rsv, rsv, min_size);
+                        steal_from_global++;
+                else
+                        steal_from_global = 0;
+                ret = 0;
 
-                if (ret) {
+                /*
+                 * steal_from_global == 0: we reserved stuff, hooray!
+                 * steal_from_global == 1: we didn't reserve stuff, boo!
+                 * steal_from_global == 2: we've committed, still not a lot of
+                 * room but maybe we'll have room in the global reserve this
+                 * time.
+                 * steal_from_global == 3: abandon all hope!
+                 */
+                if (steal_from_global > 2) {
                         btrfs_warn(root->fs_info,
                                 "Could not get space for a delete, will truncate on mount %d",
                                 ret);
@@ -5009,10 +5110,40 @@ void btrfs_evict_inode(struct inode *inode)
                         goto no_delete;
                 }
 
+                /*
+                 * We can't just steal from the global reserve, we need tomake
+                 * sure there is room to do it, if not we need to commit and try
+                 * again.
+                 */
+                if (steal_from_global) {
+                        if (!btrfs_check_space_for_delayed_refs(trans, root))
+                                ret = btrfs_block_rsv_migrate(global_rsv, rsv,
+                                                              min_size);
+                        else
+                                ret = -ENOSPC;
+                }
+
+                /*
+                 * Couldn't steal from the global reserve, we have too much
+                 * pending stuff built up, commit the transaction and try it
+                 * again.
+                 */
+                if (ret) {
+                        ret = btrfs_commit_transaction(trans, root);
+                        if (ret) {
+                                btrfs_orphan_del(NULL, inode);
+                                btrfs_free_block_rsv(root, rsv);
+                                goto no_delete;
+                        }
+                        continue;
+                } else {
+                        steal_from_global = 0;
+                }
+
                 trans->block_rsv = rsv;
 
                 ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
-                if (ret != -ENOSPC)
+                if (ret != -ENOSPC && ret != -EAGAIN)
                         break;
 
                 trans->block_rsv = &root->fs_info->trans_block_rsv;
@@ -8581,7 +8712,7 @@ static int btrfs_truncate(struct inode *inode)
                 ret = btrfs_truncate_inode_items(trans, root, inode,
                                                  inode->i_size,
                                                  BTRFS_EXTENT_DATA_KEY);
-                if (ret != -ENOSPC) {
+                if (ret != -ENOSPC && ret != -EAGAIN) {
                         err = ret;
                         break;
                 }
@@ -9451,6 +9582,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                 btrfs_end_transaction(trans, root);
                         break;
                 }
+
                 btrfs_drop_extent_cache(inode, cur_offset,
                                         cur_offset + ins.offset -1, 0);