Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/josef/btrfs-next into for-linus-3.9

6 files changed, 120 insertions, 67 deletions

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 02369a3c162e..7d84651e850b 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -62,7 +62,7 @@ static void btrfs_destroy_ordered_operations(struct btrfs_transaction *t,
 static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
 static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
                                       struct btrfs_root *root);
-static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
+static void btrfs_evict_pending_snapshots(struct btrfs_transaction *t);
 static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
 static int btrfs_destroy_marked_extents(struct btrfs_root *root,
                                         struct extent_io_tree *dirty_pages,
@@ -3687,7 +3687,7 @@ int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
         return ret;
 }
 
-static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
+static void btrfs_evict_pending_snapshots(struct btrfs_transaction *t)
 {
         struct btrfs_pending_snapshot *snapshot;
         struct list_head splice;
@@ -3700,10 +3700,8 @@ static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
                 snapshot = list_entry(splice.next,
                                       struct btrfs_pending_snapshot,
                                       list);
-
+                snapshot->error = -ECANCELED;
                 list_del_init(&snapshot->list);
-
-                kfree(snapshot);
         }
 }
 
@@ -3840,6 +3838,8 @@ void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
         cur_trans->blocked = 1;
         wake_up(&root->fs_info->transaction_blocked_wait);
 
+        btrfs_evict_pending_snapshots(cur_trans);
+
         cur_trans->blocked = 0;
         wake_up(&root->fs_info->transaction_wait);
 
@@ -3849,8 +3849,6 @@ void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
         btrfs_destroy_delayed_inodes(root);
         btrfs_assert_delayed_root_empty(root);
 
-        btrfs_destroy_pending_snapshots(cur_trans);
-
         btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
                                      EXTENT_DIRTY);
         btrfs_destroy_pinned_extent(root,
@@ -3894,6 +3892,8 @@ int btrfs_cleanup_transaction(struct btrfs_root *root)
                 if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
                         wake_up(&root->fs_info->transaction_blocked_wait);
 
+                btrfs_evict_pending_snapshots(t);
+
                 t->blocked = 0;
                 smp_mb();
                 if (waitqueue_active(&root->fs_info->transaction_wait))
@@ -3907,8 +3907,6 @@ int btrfs_cleanup_transaction(struct btrfs_root *root)
                 btrfs_destroy_delayed_inodes(root);
                 btrfs_assert_delayed_root_empty(root);
 
-                btrfs_destroy_pending_snapshots(t);
-
                 btrfs_destroy_delalloc_inodes(root);
 
                 spin_lock(&root->fs_info->trans_lock);
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index b908960c9746..898c5729e7e5 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -527,6 +527,8 @@ fail:
         if (async_transid) {
                 *async_transid = trans->transid;
                 err = btrfs_commit_transaction_async(trans, root, 1);
+                if (err)
+                        err = btrfs_commit_transaction(trans, root);
         } else {
                 err = btrfs_commit_transaction(trans, root);
         }
@@ -592,16 +594,14 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
                 *async_transid = trans->transid;
                 ret = btrfs_commit_transaction_async(trans,
                                      root->fs_info->extent_root, 1);
+                if (ret)
+                        ret = btrfs_commit_transaction(trans, root);
         } else {
                 ret = btrfs_commit_transaction(trans,
                                                root->fs_info->extent_root);
         }
-        if (ret) {
-                /* cleanup_transaction has freed this for us */
-                if (trans->aborted)
-                        pending_snapshot = NULL;
+        if (ret)
                 goto fail;
-        }
 
         ret = pending_snapshot->error;
         if (ret)
@@ -2245,13 +2245,6 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
         if (ret)
                 return ret;
 
-        if (atomic_xchg(&root->fs_info->mutually_exclusive_operation_running,
-                        1)) {
-                pr_info("btrfs: dev add/delete/balance/replace/resize operation in progress\n");
-                mnt_drop_write_file(file);
-                return -EINVAL;
-        }
-
         if (btrfs_root_readonly(root)) {
                 ret = -EROFS;
                 goto out;
@@ -2306,7 +2299,6 @@ static int btrfs_ioctl_defrag(struct file *file, void __user *argp)
                 ret = -EINVAL;
         }
 out:
-        atomic_set(&root->fs_info->mutually_exclusive_operation_running, 0);
         mnt_drop_write_file(file);
         return ret;
 }
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index ba5a3210da9a..3ebe87977aae 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1269,6 +1269,8 @@ static int __update_reloc_root(struct btrfs_root *root, int del)
         }
         spin_unlock(&rc->reloc_root_tree.lock);
 
+        if (!node)
+                return 0;
         BUG_ON((struct btrfs_root *)node->data != root);
 
         if (!del) {
@@ -2238,13 +2240,28 @@ again:
 }
 
 static noinline_for_stack
+void free_reloc_roots(struct list_head *list)
+{
+        struct btrfs_root *reloc_root;
+
+        while (!list_empty(list)) {
+                reloc_root = list_entry(list->next, struct btrfs_root,
+                                        root_list);
+                __update_reloc_root(reloc_root, 1);
+                free_extent_buffer(reloc_root->node);
+                free_extent_buffer(reloc_root->commit_root);
+                kfree(reloc_root);
+        }
+}
+
+static noinline_for_stack
 int merge_reloc_roots(struct reloc_control *rc)
 {
         struct btrfs_root *root;
         struct btrfs_root *reloc_root;
         LIST_HEAD(reloc_roots);
         int found = 0;
-        int ret;
+        int ret = 0;
 again:
         root = rc->extent_root;
 
@@ -2270,20 +2287,33 @@ again:
                         BUG_ON(root->reloc_root != reloc_root);
 
                         ret = merge_reloc_root(rc, root);
-                        BUG_ON(ret);
+                        if (ret)
+                                goto out;
                 } else {
                         list_del_init(&reloc_root->root_list);
                 }
                 ret = btrfs_drop_snapshot(reloc_root, rc->block_rsv, 0, 1);
-                BUG_ON(ret < 0);
+                if (ret < 0) {
+                        if (list_empty(&reloc_root->root_list))
+                                list_add_tail(&reloc_root->root_list,
+                                              &reloc_roots);
+                        goto out;
+                }
         }
 
         if (found) {
                 found = 0;
                 goto again;
         }
+out:
+        if (ret) {
+                btrfs_std_error(root->fs_info, ret);
+                if (!list_empty(&reloc_roots))
+                        free_reloc_roots(&reloc_roots);
+        }
+
         BUG_ON(!RB_EMPTY_ROOT(&rc->reloc_root_tree.rb_root));
-        return 0;
+        return ret;
 }
 
 static void free_block_list(struct rb_root *blocks)
@@ -2818,8 +2848,10 @@ int relocate_tree_blocks(struct btrfs_trans_handle *trans,
         int err = 0;
 
         path = btrfs_alloc_path();
-        if (!path)
-                return -ENOMEM;
+        if (!path) {
+                err = -ENOMEM;
+                goto out_path;
+        }
 
         rb_node = rb_first(blocks);
         while (rb_node) {
@@ -2858,10 +2890,11 @@ int relocate_tree_blocks(struct btrfs_trans_handle *trans,
                 rb_node = rb_next(rb_node);
         }
 out:
-        free_block_list(blocks);
         err = finish_pending_nodes(trans, rc, path, err);
 
         btrfs_free_path(path);
+out_path:
+        free_block_list(blocks);
         return err;
 }
 
@@ -3698,7 +3731,15 @@ int prepare_to_relocate(struct reloc_control *rc)
         set_reloc_control(rc);
 
         trans = btrfs_join_transaction(rc->extent_root);
-        BUG_ON(IS_ERR(trans));
+        if (IS_ERR(trans)) {
+                unset_reloc_control(rc);
+                /*
+                 * extent tree is not a ref_cow tree and has no reloc_root to
+                 * cleanup.  And callers are responsible to free the above
+                 * block rsv.
+                 */
+                return PTR_ERR(trans);
+        }
         btrfs_commit_transaction(trans, rc->extent_root);
         return 0;
 }
@@ -3730,7 +3771,11 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
         while (1) {
                 progress++;
                 trans = btrfs_start_transaction(rc->extent_root, 0);
-                BUG_ON(IS_ERR(trans));
+                if (IS_ERR(trans)) {
+                        err = PTR_ERR(trans);
+                        trans = NULL;
+                        break;
+                }
 restart:
                 if (update_backref_cache(trans, &rc->backref_cache)) {
                         btrfs_end_transaction(trans, rc->extent_root);
@@ -4264,14 +4309,9 @@ int btrfs_recover_relocation(struct btrfs_root *root)
 out_free:
         kfree(rc);
 out:
-        while (!list_empty(&reloc_roots)) {
-                reloc_root = list_entry(reloc_roots.next,
-                                        struct btrfs_root, root_list);
-                list_del(&reloc_root->root_list);
-                free_extent_buffer(reloc_root->node);
-                free_extent_buffer(reloc_root->commit_root);
-                kfree(reloc_root);
-        }
+        if (!list_empty(&reloc_roots))
+                free_reloc_roots(&reloc_roots);
+
         btrfs_free_path(path);
 
         if (err == 0) {
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index f11c2e0a3746..fedede1fe178 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1053,7 +1053,12 @@ int btrfs_defrag_root(struct btrfs_root *root)
 
 /*
  * new snapshots need to be created at a very specific time in the
- * transaction commit.  This does the actual creation
+ * transaction commit.  This does the actual creation.
+ *
+ * Note:
+ * If the error which may affect the commitment of the current transaction
+ * happens, we should return the error number. If the error which just affect
+ * the creation of the pending snapshots, just return 0.
  */
 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                                    struct btrfs_fs_info *fs_info,
@@ -1072,7 +1077,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         struct extent_buffer *tmp;
         struct extent_buffer *old;
         struct timespec cur_time = CURRENT_TIME;
-        int ret;
+        int ret = 0;
         u64 to_reserve = 0;
         u64 index = 0;
         u64 objectid;
@@ -1081,40 +1086,36 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
 
         path = btrfs_alloc_path();
         if (!path) {
-                ret = pending->error = -ENOMEM;
-                return ret;
+                pending->error = -ENOMEM;
+                return 0;
         }
 
         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
         if (!new_root_item) {
-                ret = pending->error = -ENOMEM;
+                pending->error = -ENOMEM;
                 goto root_item_alloc_fail;
         }
 
-        ret = btrfs_find_free_objectid(tree_root, &objectid);
-        if (ret) {
-                pending->error = ret;
+        pending->error = btrfs_find_free_objectid(tree_root, &objectid);
+        if (pending->error)
                 goto no_free_objectid;
-        }
 
         btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
 
         if (to_reserve > 0) {
-                ret = btrfs_block_rsv_add(root, &pending->block_rsv,
-                                          to_reserve,
-                                          BTRFS_RESERVE_NO_FLUSH);
-                if (ret) {
-                        pending->error = ret;
+                pending->error = btrfs_block_rsv_add(root,
+                                                     &pending->block_rsv,
+                                                     to_reserve,
+                                                     BTRFS_RESERVE_NO_FLUSH);
+                if (pending->error)
                         goto no_free_objectid;
-                }
         }
 
-        ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
-                                   objectid, pending->inherit);
-        if (ret) {
-                pending->error = ret;
+        pending->error = btrfs_qgroup_inherit(trans, fs_info,
+                                              root->root_key.objectid,
+                                              objectid, pending->inherit);
+        if (pending->error)
                 goto no_free_objectid;
-        }
 
         key.objectid = objectid;
         key.offset = (u64)-1;
@@ -1142,7 +1143,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                                          dentry->d_name.len, 0);
         if (dir_item != NULL && !IS_ERR(dir_item)) {
                 pending->error = -EEXIST;
-                goto fail;
+                goto dir_item_existed;
         } else if (IS_ERR(dir_item)) {
                 ret = PTR_ERR(dir_item);
                 btrfs_abort_transaction(trans, root, ret);
@@ -1273,6 +1274,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
         if (ret)
                 btrfs_abort_transaction(trans, root, ret);
 fail:
+        pending->error = ret;
+dir_item_existed:
         trans->block_rsv = rsv;
         trans->bytes_reserved = 0;
 no_free_objectid:
@@ -1288,12 +1291,17 @@ root_item_alloc_fail:
 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
                                              struct btrfs_fs_info *fs_info)
 {
-        struct btrfs_pending_snapshot *pending;
+        struct btrfs_pending_snapshot *pending, *next;
         struct list_head *head = &trans->transaction->pending_snapshots;
+        int ret = 0;
 
-        list_for_each_entry(pending, head, list)
-                create_pending_snapshot(trans, fs_info, pending);
-        return 0;
+        list_for_each_entry_safe(pending, next, head, list) {
+                list_del(&pending->list);
+                ret = create_pending_snapshot(trans, fs_info, pending);
+                if (ret)
+                        break;
+        }
+        return ret;
 }
 
 static void update_super_roots(struct btrfs_root *root)
@@ -1449,6 +1457,13 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans,
         btrfs_abort_transaction(trans, root, err);
 
         spin_lock(&root->fs_info->trans_lock);
+
+        if (list_empty(&cur_trans->list)) {
+                spin_unlock(&root->fs_info->trans_lock);
+                btrfs_end_transaction(trans, root);
+                return;
+        }
+
         list_del_init(&cur_trans->list);
         if (cur_trans == root->fs_info->running_transaction) {
                 root->fs_info->trans_no_join = 1;
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index c7ef569eb22a..451fad96ecd1 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -1382,7 +1382,10 @@ static noinline int link_to_fixup_dir(struct btrfs_trans_handle *trans,
 
         btrfs_release_path(path);
         if (ret == 0) {
-                btrfs_inc_nlink(inode);
+                if (!inode->i_nlink)
+                        set_nlink(inode, 1);
+                else
+                        btrfs_inc_nlink(inode);
                 ret = btrfs_update_inode(trans, root, inode);
         } else if (ret == -EEXIST) {
                 ret = 0;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 35bb2d4ed29f..9ff454df6756 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2379,7 +2379,11 @@ static int btrfs_relocate_chunk(struct btrfs_root *root,
                 return ret;
 
         trans = btrfs_start_transaction(root, 0);
-        BUG_ON(IS_ERR(trans));
+        if (IS_ERR(trans)) {
+                ret = PTR_ERR(trans);
+                btrfs_std_error(root->fs_info, ret);
+                return ret;
+        }
 
         lock_chunks(root);
 
@@ -3050,7 +3054,8 @@ static void __cancel_balance(struct btrfs_fs_info *fs_info)
 
         unset_balance_control(fs_info);
         ret = del_balance_item(fs_info->tree_root);
-        BUG_ON(ret);
+        if (ret)
+                btrfs_std_error(fs_info, ret);
 
         atomic_set(&fs_info->mutually_exclusive_operation_running, 0);
 }